Gemini 3.8 Flash është tani në dispozicion. Provojeni .

Kjo faqe është përkthyer nga Cloud Translation API.

Përdorimi i kompjuterit

Mjeti "Përdorimi i Kompjuterit" ju lejon të ndërtoni agjentë kontrolli për shfletues, celular dhe desktop që bashkëveprojnë me detyrat dhe automatizojnë ato. Duke përdorur pamje të ekranit, modeli mund të "shohë" një ekran kompjuteri dhe të "veprojë" duke gjeneruar veprime specifike të ndërfaqes së përdoruesit, si klikimet e miut dhe hyrjet e tastierës. Ngjashëm me thirrjen e funksioneve, do t'ju duhet të zbatoni mjedisin e ekzekutimit në anën e klientit për të marrë dhe ekzekutuar veprimet e "Përdorimit të Kompjuterit".

Për listën e modeleve të mbështetura, shihni Versionet e modelit . Modelet Gemini 3.x mbështesin disa aftësi të përparuara:

Mbështetje për shumë mjedise: ndërtoni agjentë për mjedise shfletuesi, celulari dhe desktopi .
Veprime të përmirësuara me qëllime: veprimet përfshijnë një fushë intent që shpjegon arsyetimin e modelit pas çdo hapi.
Politikat e sigurisë të konfigurueshme: rregulloni sjelljen e sigurisë me kategori dhe mbishkrime të integruara të politikave.
Zbulim i shpejtë i injektimit: skanim i pamjeve të ekranit me zgjedhje për të zbuluar udhëzime të fshehura kundërshtare.

Me Përdorimin e Kompjuterit, ju mund të ndërtoni agjentë që:

Automatizoni futjen e përsëritur të të dhënave ose plotësimin e formularëve në faqet e internetit.
Kryeni testime automatike të aplikacioneve web dhe rrjedhave të përdoruesve
Kryeni kërkime nëpër faqe të ndryshme interneti (p.sh., mbledhja e informacionit të produktit, çmimeve dhe vlerësimeve nga faqet e tregtisë elektronike për të informuar një blerje)

Ja një shembull minimal i inicializimit të klientit dhe dërgimit të një mesazhi te modeli me mjetin computer_use të aktivizuar për një mjedis shfletuesi:

Python

from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-3.8-flash",
    input="Search for 'Gemini API' on Google.",
    tools=[{"type": "computer_use", "environment": "browser"}]
)

print(interaction)

JavaScript

import { GoogleGenAI } from '@google/genai';

const ai = new GoogleGenAI();

const interaction = await ai.interactions.create({
  model: 'gemini-3.8-flash',
  input: "Search for 'Gemini API' on Google.",
  tools: [{ type: "computer_use", environment: "browser" }]
});

console.log(interaction);

Java

import com.google.genai.Client;
import com.google.genai.gaos.models.interactions.ComputerUse;
import com.google.genai.gaos.models.interactions.CreateModelInteraction;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.Model;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
import java.util.Arrays;

Client client = new Client();

CreateModelInteraction params =
    CreateModelInteraction.builder()
        .model(Model.of("gemini-3.8-flash"))
        .input(InteractionsInput.of("Click the Submit button on the screen."))
        .tools(Arrays.asList(new ComputerUse()))
        .build();

Interaction interaction =
    client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();

System.out.println(interaction.outputText().orElse(""));

Si funksionon përdorimi i kompjuterit

Për të ndërtuar një agjent me modelin e Përdorimit të Kompjuterit, duhet të konfiguroni një cikël të vazhdueshëm midis aplikacionit tuaj dhe API-t. Ja çfarë do të bëjë kodi juaj në secilin hap:

Dërgoni një kërkesë te modeli
- Aplikacioni juaj dërgon një kërkesë API që përmban mjetin e Përdorimit të Kompjuterit, cilësimet e konfigurimit tuaj (si mjedisi i synuar), kërkesën e përdoruesit dhe një pamje të ekranit aktual.
Merrni përgjigjen e modelit
- Modeli analizon ekranin dhe kërkesën, duke kthyer një përgjigje që përfshin një function_call të sugjeruar që përfaqëson një veprim të ndërfaqes së përdoruesit (siç është një klikim, lëvizje me lëvizje ose shtypje tastiere).
- Për modelet Gemini 3.x , përgjigjja përfshin gjithashtu një intent arsyetimi që shpjegon pse modeli zgjodhi atë veprim.
- Përgjigja mund të përfshijë gjithashtu një safety_decision nga një sistem i brendshëm sigurie që e klasifikon veprimin si të rregullt/të lejuar, require_confirmation (që kërkon miratimin e përdoruesit) ose të bllokuar.
Ekzekutoni veprimin e marrë
- Nëse veprimi lejohet (ose përdoruesi e konfirmon atë), kodi juaj në anën e klientit analizon function_call , shkallëzon koordinatat e normalizuara që të përputhen me pamjen tuaj dhe ekzekuton veprimin në mjedisin tuaj të synuar duke përdorur mjete automatizimi (siç është Playwright). Nëse veprimi bllokohet, klienti juaj duhet ta ndalojë ekzekutimin ose të trajtojë ndërprerjen.
Kap gjendjen e re të mjedisit
- Pasi veprimi të përfundojë ekzekutimin, aplikacioni juaj kap një pamje të re të ekranit dhe ia dërgon atë modelit në një function_result për të kërkuar hapin tjetër.

Ky proces përsëritet nga hapi 2, duke kërkuar vazhdimisht veprimin tjetër nga modeli derisa detyra të përfundojë ose të ndërpritet.

Përmbledhje e përdorimit të kompjuterit

Si të zbatohet përdorimi i kompjuterit

Përpara se të ndërtoni me mjetin Përdorimi i Kompjuterit, do t'ju duhet të konfiguroni:

Mjedis i sigurt ekzekutimi: Ekzekutoni agjentin tuaj në një VM ose kontejner të sandboxuar për ta izoluar atë nga sistemi juaj pritës dhe për të kufizuar ndikimin e tij të mundshëm. Implementimi i referencës përfshin një sandbox të bazuar në Docker, gati për përdorim, që mund ta përdorni si pikënisje.
Trajneri i veprimeve në anën e klientit: Implementoni logjikën në anën e klientit për të ekzekutuar koordinatat, për të shkruar tekst dhe për të marrë pamje të ekranit.

Shembujt më poshtë përdorin një shfletues uebi si mjedis ekzekutimi dhe Playwright si trajtuesin në anën e klientit.

0. Ngritja e Dramaturgut

Së pari, instaloni paketat e nevojshme:

pip install google-genai playwright
playwright install chromium

Pastaj, inicializoni një instancë të shfletuesit Playwright për ta përdorur për ekzekutim:

from playwright.sync_api import sync_playwright

# 1. Configure screen dimensions for the target environment
SCREEN_WIDTH = 1440
SCREEN_HEIGHT = 900

# 2. Start the Playwright browser
# In production, utilize a sandboxed environment.
playwright = sync_playwright().start()
# Set headless=False to see the actions performed on your screen
browser = playwright.chromium.launch(headless=False)

# 3. Create a context and page with the specified dimensions
context = browser.new_context(
    viewport={"width": SCREEN_WIDTH, "height": SCREEN_HEIGHT}
)
page = context.new_page()

# 4. Navigate to an initial page to start the task
page.goto("https://www.google.com")

# The 'page', 'SCREEN_WIDTH', and 'SCREEN_HEIGHT' variables
# will be used in the steps below.

1. Dërgoni një kërkesë te modeli

Inicializoni bibliotekën e klientit dhe konfiguroni mjetin Përdorimi i Kompjuterit. Vini re se nuk ka nevojë të specifikoni madhësinë e ekranit kur lëshoni një kërkesë; modeli parashikon koordinatat e pikselëve të shkallëzuara në lartësinë dhe gjerësinë e ekranit.

Binjakët 3.x

Python

Përdorni SDK-në Python google-genai (versioni 2.7.0 ose më i lartë) për të konfiguruar një kërkesë që synon mjedisin e shfletuesit:

from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model='gemini-3.8-flash',
    input="Find a flight from SF to Hawaii on Jun 30th, coming back on Jul 6th",
    tools=[
        {
            "type": "computer_use",
            "environment": "browser",
            "enable_prompt_injection_detection": True
        }
    ]
)

print(interaction)

JavaScript

Përdorni SDK-në @google/genai Node.js për të konfiguruar një kërkesë që synon mjedisin e shfletuesit:

import { GoogleGenAI } from '@google/genai';

const ai = new GoogleGenAI();

const interaction = await ai.interactions.create({
  model: 'gemini-3.8-flash',
  input: "Find a flight from SF to Hawaii on Jun 30th, coming back on Jul 6th",
  tools: [
    {
      type: "computer_use",
      environment: "browser",
      enable_prompt_injection_detection: true
    }
  ]
});

console.log(interaction);

Java

import com.google.genai.Client;
import com.google.genai.gaos.models.interactions.ComputerUse;
import com.google.genai.gaos.models.interactions.CreateModelInteraction;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.Model;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
import java.util.Arrays;

Client client = new Client();

CreateModelInteraction params =
    CreateModelInteraction.builder()
        .model(Model.of("gemini-3.8-flash"))
        .input(InteractionsInput.of("Click the Submit button on the screen."))
        .tools(Arrays.asList(new ComputerUse()))
        .build();

Interaction interaction =
    client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();

System.out.println(interaction.outputText().orElse(""));

PUSHTIM

Përdorni curl për të dërguar një kërkesë:

curl -X POST \
  "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-3.8-flash",
    "input": "Find me a flight from SF to Hawaii on Jun 30th, coming back on Jul 6th. Start by navigating directly to flights.google.com",
    "tools": [
      {
        "type": "computer_use",
        "environment": "browser",
        "enable_prompt_injection_detection": true
      }
    ]
  }'

Binjakët 2.5 (Trashëgimi)

Python

from google import genai

client = genai.Client()

# Specify predefined functions to exclude (optional)
excluded_functions = ["drag_and_drop"]

interaction = client.interactions.create(
    model='gemini-2.5-computer-use-preview-10-2025',
    input="Search for highly rated smart fridges on Google Shopping.",
    tools=[
        {
            "type": "computer_use",
            "environment": "browser",
            "excluded_predefined_functions": excluded_functions
        }
    ]
)

print(interaction)

JavaScript

import { GoogleGenAI } from '@google/genai';

const ai = new GoogleGenAI();

// Specify predefined functions to exclude (optional)
const excludedFunctions = ["drag_and_drop"];

const interaction = await ai.interactions.create({
  model: 'gemini-2.5-computer-use-preview-10-2025',
  input: "Search for highly rated smart fridges on Google Shopping.",
  tools: [
    {
      type: "computer_use",
      environment: "browser",
      excluded_predefined_functions: excludedFunctions
    }
  ]
});

console.log(interaction);

Java

import com.google.genai.Client;
import com.google.genai.gaos.models.interactions.ComputerUse;
import com.google.genai.gaos.models.interactions.CreateModelInteraction;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.Model;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
import java.util.Arrays;

Client client = new Client();

CreateModelInteraction params =
    CreateModelInteraction.builder()
        .model(Model.of("gemini-3.8-flash"))
        .input(InteractionsInput.of("Click the Submit button on the screen."))
        .tools(Arrays.asList(new ComputerUse()))
        .build();

Interaction interaction =
    client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();

System.out.println(interaction.outputText().orElse(""));

2. Merrni përgjigjen e modelit

Modeli i përgjigjes sugjeron një thirrje funksioni. Për modelet Gemini 3.x , përgjigja përmban një qëllim arsyetimi të përshtatur së bashku me koordinatat. Më poshtë tregohen shembuj të të dy përgjigjeve:

Binjakët 3.x

{
  "steps": [
    {
      "type": "function_call",
      "name": "click",
      "arguments": {
        "x": 450,
        "y": 120,
        "intent": "Click the search box to type the destination."
      }
    }
  ]
}

Binjakët 2.5 (Trashëgimi)

{
  "steps": [
    {
      "type": "model_output",
      "content": [
        {
          "type": "text",
          "text": "I will type the search query into the search bar."
        }
      ]
    },
    {
      "type": "function_call",
      "name": "type_text_at",
      "arguments": {
        "x": 371,
        "y": 470,
        "text": "highly rated smart fridges",
        "press_enter": true
      }
    }
  ]
}

3. Ekzekutoni veprimet e marra

Aplikacioni juaj duhet të analizojë koordinatat e përgjigjes, të ekzekutojë veprimin dhe t'i shkallëzojë ato nga koordinatat e normalizuara 1000x1000.

Kodi më poshtë trajton si komandat e mjeteve të trashëguara ( click_at , type_text_at ) ashtu edhe komandat moderne të thjeshtuara ( click , type ).

Python

from typing import Any, List, Tuple
import time

def denormalize_x(x: int, screen_width: int) -> int:
    """Convert normalized x coordinate (0-1000) to actual pixel coordinate."""
    return int(x / 1000 * screen_width)

def denormalize_y(y: int, screen_height: int) -> int:
    """Convert normalized y coordinate (0-1000) to actual pixel coordinate."""
    return int(y / 1000 * screen_height)

def execute_function_calls(interaction, page, screen_width, screen_height):
    results = []
    function_calls = [
        step for step in interaction.steps if step.type == "function_call"
    ]

    for function_call in function_calls:
        action_result = {}
        fname = function_call.name
        args = function_call.arguments
        print(f"  -> Executing: {fname} (Intent: {args.get('intent', 'N/A')})")

        try:
            if fname in ("open_web_browser", "open_app"):
                pass # Handled / already open
            elif fname in ("click", "click_at", "double_click", "triple_click", "middle_click", "right_click", "move", "long_press"):
                actual_x = denormalize_x(args["x"], screen_width)
                actual_y = denormalize_y(args["y"], screen_height)

                if fname in ("click", "click_at"):
                    page.mouse.click(actual_x, actual_y)
                elif fname == "double_click":
                    page.mouse.dblclick(actual_x, actual_y)
                elif fname == "right_click":
                    page.mouse.click(actual_x, actual_y, button="right")
                elif fname == "middle_click":
                    page.mouse.click(actual_x, actual_y, button="middle")
                elif fname == "move":
                    page.mouse.move(actual_x, actual_y)
            elif fname in ("type", "type_text_at"):
                actual_x = denormalize_x(args["x"], screen_width) if "x" in args else None
                actual_y = denormalize_y(args["y"], screen_height) if "y" in args else None
                text = args["text"]
                press_enter = args.get("press_enter", False)

                if actual_x is not None and actual_y is not None:
                    page.mouse.click(actual_x, actual_y)
                # Clear field first
                page.keyboard.press("Meta+A")
                page.keyboard.press("Backspace")
                page.keyboard.type(text)
                if press_enter:
                    page.keyboard.press("Enter")
            elif fname == "navigate":
                page.goto(args["url"])
            elif fname == "go_back":
                page.go_back()
            elif fname == "go_forward":
                page.go_forward()
            elif fname == "wait":
                time.sleep(args.get("seconds", 1))
            else:
                print(f"Warning: Custom or unhandled function {fname}")

            page.wait_for_load_state(timeout=5000)
            time.sleep(1)

        except Exception as e:
            print(f"Error executing {fname}: {e}")
            action_result = {"error": str(e)}

        results.append((fname, function_call.id, action_result))

    return results

JavaScript

function denormalizeX(x, screenWidth) {
    // Convert normalized x coordinate (0-1000) to actual pixel coordinate.
    return Math.floor((x / 1000) * screenWidth);
}

function denormalizeY(y, screenHeight) {
    // Convert normalized y coordinate (0-1000) to actual pixel coordinate.
    return Math.floor((y / 1000) * screenHeight);
}

async function executeFunctionCalls(interaction, page, screenWidth, screenHeight) {
    const results = [];
    const functionCalls = interaction.steps.filter(step => step.type === "function_call");

    for (const functionCall of functionCalls) {
        const actionResult = {};
        const fname = functionCall.name;
        const args = functionCall.arguments;
        console.log(`  -> Executing: ${fname} (Intent: ${args.intent || 'N/A'})`);

        try {
            if (fname === "open_web_browser" || fname === "open_app") {
                // Handled / already open
            } else if (["click", "click_at", "double_click", "triple_click", "middle_click", "right_click", "move", "long_press"].includes(fname)) {
                const actualX = denormalizeX(args.x, screenWidth);
                const actualY = denormalizeY(args.y, screenHeight);

                if (fname === "click" || fname === "click_at") {
                    await page.mouse.click(actualX, actualY);
                } else if (fname === "double_click") {
                    await page.mouse.dblclick(actualX, actualY);
                } else if (fname === "right_click") {
                    await page.mouse.click(actualX, actualY, { button: "right" });
                } else if (fname === "middle_click") {
                    await page.mouse.click(actualX, actualY, { button: "middle" });
                } else if (fname === "move") {
                    await page.mouse.move(actualX, actualY);
                }
            } else if (fname === "type" || fname === "type_text_at") {
                const actualX = args.x !== undefined ? denormalizeX(args.x, screenWidth) : null;
                const actualY = args.y !== undefined ? denormalizeY(args.y, screenHeight) : null;
                const text = args.text;
                const pressEnter = args.press_enter || false;

                if (actualX !== null && actualY !== null) {
                    await page.mouse.click(actualX, actualY);
                }
                // Clear field first
                await page.keyboard.press("Meta+A");
                await page.keyboard.press("Backspace");
                await page.keyboard.type(text);
                if (pressEnter) {
                    await page.keyboard.press("Enter");
                }
            } else if (fname === "navigate") {
                await page.goto(args.url);
            } else if (fname === "go_back") {
                await page.goBack();
            } else if (fname === "go_forward") {
                await page.goForward();
            } else if (fname === "wait") {
                await new Promise(resolve => setTimeout(resolve, (args.seconds || 1) * 1000));
            } else {
                console.log(`Warning: Custom or unhandled function ${fname}`);
            }

            await page.waitForLoadState('load', { timeout: 5000 }).catch(() => {});
            await new Promise(resolve => setTimeout(resolve, 1000));
        } catch (e) {
            console.log(`Error executing ${fname}: ${e}`);
            actionResult.error = e.message;
        }

        results.push([fname, functionCall.id, actionResult]);
    }

    return results;
}

Java

import com.google.genai.Client;
import com.google.genai.gaos.models.interactions.ComputerUse;
import com.google.genai.gaos.models.interactions.CreateModelInteraction;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.Model;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
import java.util.Arrays;

Client client = new Client();

CreateModelInteraction params =
    CreateModelInteraction.builder()
        .model(Model.of("gemini-3.8-flash"))
        .input(InteractionsInput.of("Click the Submit button on the screen."))
        .tools(Arrays.asList(new ComputerUse()))
        .build();

Interaction interaction =
    client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();

System.out.println(interaction.outputText().orElse(""));

4. Kapni gjendjen e re të mjedisit

Pas ekzekutimit të veprimeve, dërgoni rezultatin e ekzekutimit të funksionit përsëri te modeli në mënyrë që të mund ta përdorë këtë informacion për të gjeneruar veprimin tjetër. Nëse janë ekzekutuar veprime të shumta (thirrje paralele), duhet të dërgoni një function_result për secilin prej tyre në kthesën pasuese të përdoruesit.

Python

import json
import base64

def get_function_responses(page, results):
    screenshot_bytes = page.screenshot(type="png")
    current_url = page.url
    function_responses = []
    for