Prezantimi i modalitetit të grupit, me kufij më të lartë të tarifave dhe një zbritje simbolike prej 50%. Mësoni më shumë

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

Binjakët duke menduar

Modelet e serisë Gemini 2.5 përdorin një "proces të të menduarit" të brendshëm që përmirëson ndjeshëm aftësitë e tyre të arsyetimit dhe planifikimit me shumë hapa, duke i bërë ato shumë efektive për detyra komplekse si kodimi, matematika e avancuar dhe analiza e të dhënave.

Ky udhëzues ju tregon se si të punoni me aftësitë e të menduarit të Gemini duke përdorur Gemini API.

Para se të filloni

Sigurohuni që të përdorni një model të mbështetur të serisë 2.5 për të menduar. Mund t'ju duket e dobishme të eksploroni këto modele në AI Studio përpara se të zhyteni në API:

Gjenerimi i përmbajtjes me të menduarit

Fillimi i një kërkese me një model të të menduarit është i ngjashëm me çdo kërkesë tjetër për gjenerimin e përmbajtjes. Dallimi kryesor qëndron në specifikimin e një prej modeleve me mbështetje të të menduarit në fushën e model , siç tregohet në shembullin e mëposhtëm të gjenerimit të tekstit :

Python

from google import genai

client = genai.Client()
prompt = "Explain the concept of Occam's Razor and provide a simple, everyday example."
response = client.models.generate_content(
    model="gemini-2.5-pro",
    contents=prompt
)

print(response.text)

JavaScript

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

const ai = new GoogleGenAI({});

async function main() {
  const prompt = "Explain the concept of Occam's Razor and provide a simple, everyday example.";

  const response = await ai.models.generateContent({
    model: "gemini-2.5-pro",
    contents: prompt,
  });

  console.log(response.text);
}

main();

Shkoni

package main

import (
  "context"
  "fmt"
  "log"
  "os"
  "google.golang.org/genai"
)

func main() {
  ctx := context.Background()
  client, err := genai.NewClient(ctx, nil)
  if err != nil {
      log.Fatal(err)
  }

  prompt := "Explain the concept of Occam's Razor and provide a simple, everyday example."
  model := "gemini-2.5-pro"

  resp, _ := client.Models.GenerateContent(ctx, model, genai.Text(prompt), nil)

  fmt.Println(resp.Text())
}

PUSHIMI

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-pro:generateContent" \
 -H "x-goog-api-key: $GEMINI_API_KEY" \
 -H 'Content-Type: application/json' \
 -X POST \
 -d '{
   "contents": [
     {
       "parts": [
         {
           "text": "Explain the concept of Occam\'s Razor and provide a simple, everyday example."
         }
       ]
     }
   ]
 }'
 ```

Mendimi i buxheteve

Parametri thinkingBudget udhëzon modelin mbi numrin e argumenteve të të menduarit që duhen përdorur kur gjenerohet një përgjigje. Një numër më i lartë i shenjave në përgjithësi lejon një arsyetim më të detajuar, i cili mund të jetë i dobishëm për trajtimin e detyrave më komplekse . Nëse vonesa është më e rëndësishme, përdorni një buxhet më të ulët ose çaktivizoni të menduarit duke vendosur thinkingBudget në 0. Vendosja e thinkingBudget në -1 aktivizon të menduarit dinamik , që do të thotë se modeli do të rregullojë buxhetin bazuar në kompleksitetin e kërkesës.

thinkingBudget mbështetet vetëm në Gemini 2.5 Flash, 2.5 Pro dhe 2.5 Flash-Lite. Në varësi të kërkesës, modeli mund të tejmbushet ose të nënshtrohet buxheti simbolik.

Më poshtë jepen detajet e konfigurimit të thinkingBudget për çdo lloj modeli.

Model	Cilësimi i parazgjedhur (Buxheti i menduar nuk është caktuar)	Gama	Çaktivizoni të menduarit	Aktivizoni të menduarit dinamik
2.5 Pro	Të menduarit dinamik: Modeli vendos kur dhe sa të mendojë	`128` deri në `32768`	N/A: Nuk mund të çaktivizojë të menduarit	`thinkingBudget = -1`
2.5 Blic	Të menduarit dinamik: Modeli vendos kur dhe sa të mendojë	`0` deri në `24576`	`thinkingBudget = 0`	`thinkingBudget = -1`
2.5 Flash Lite	Modelja nuk mendon	`512` deri në `24576`	`thinkingBudget = 0`	`thinkingBudget = -1`

Python

from google import genai
from google.genai import types

client = genai.Client()

response = client.models.generate_content(
    model="gemini-2.5-pro",
    contents="Provide a list of 3 famous physicists and their key contributions",
    config=types.GenerateContentConfig(
        thinking_config=types.ThinkingConfig(thinking_budget=1024)
        # Turn off thinking:
        # thinking_config=types.ThinkingConfig(thinking_budget=0)
        # Turn on dynamic thinking:
        # thinking_config=types.ThinkingConfig(thinking_budget=-1)
    ),
)

print(response.text)

JavaScript

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

const ai = new GoogleGenAI({});

async function main() {
  const response = await ai.models.generateContent({
    model: "gemini-2.5-pro",
    contents: "Provide a list of 3 famous physicists and their key contributions",
    config: {
      thinkingConfig: {
        thinkingBudget: 1024,
        // Turn off thinking:
        // thinkingBudget: 0
        // Turn on dynamic thinking:
        // thinkingBudget: -1
      },
    },
  });

  console.log(response.text);
}

main();

Shkoni

package main

import (
  "context"
  "fmt"
  "google.golang.org/genai"
  "os"
)

func main() {
  ctx := context.Background()
  client, err := genai.NewClient(ctx, nil)
  if err != nil {
      log.Fatal(err)
  }

  thinkingBudgetVal := int32(1024)

  contents := genai.Text("Provide a list of 3 famous physicists and their key contributions")
  model := "gemini-2.5-pro"
  resp, _ := client.Models.GenerateContent(ctx, model, contents, &genai.GenerateContentConfig{
    ThinkingConfig: &genai.ThinkingConfig{
      ThinkingBudget: &thinkingBudgetVal,
      // Turn off thinking:
      // ThinkingBudget: int32(0),
      // Turn on dynamic thinking:
      // ThinkingBudget: int32(-1),
    },
  })

fmt.Println(resp.Text())
}

PUSHIMI

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-pro:generateContent" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-H 'Content-Type: application/json' \
-X POST \
-d '{
  "contents": [
    {
      "parts": [
        {
          "text": "Provide a list of 3 famous physicists and their key contributions"
        }
      ]
    }
  ],
  "generationConfig": {
    "thinkingConfig": {
          "thinkingBudget": 1024
          # Thinking off:
          # "thinkingBudget": 0
          # Turn on dynamic thinking:
          # "thinkingBudget": -1
    }
  }
}'

Përmbledhje mendimesh

Përmbledhjet e mendimeve janë versione të sintetizuara të mendimeve të papërpunuara të modelit dhe ofrojnë njohuri në procesin e arsyetimit të brendshëm të modelit. Vini re se buxhetet e të menduarit zbatohen për mendimet e papërpunuara të modelit dhe jo për përmbledhjet e mendimeve.

Ju mund të aktivizoni përmbledhjet e mendimeve duke vendosur includeThoughts në true në konfigurimin e kërkesës tuaj. Më pas mund t'i qaseni përmbledhjes duke përsëritur parts e parametrit response dhe duke kontrolluar boolean-in thought .

Këtu është një shembull që demonstron se si të mundësohen dhe të merren përmbledhjet e mendimeve pa transmetim, i cili kthen një përmbledhje të vetme, përfundimtare të mendimit me përgjigjen:

Python

from google import genai
from google.genai import types

client = genai.Client()
prompt = "What is the sum of the first 50 prime numbers?"
response = client.models.generate_content(
  model="gemini-2.5-pro",
  contents=prompt,
  config=types.GenerateContentConfig(
    thinking_config=types.ThinkingConfig(
      include_thoughts=True
    )
  )
)

for part in response.candidates[0].content.parts:
  if not part.text:
    continue
  if part.thought:
    print("Thought summary:")
    print(part.text)
    print()
  else:
    print("Answer:")
    print(part.text)
    print()

JavaScript

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

const ai = new GoogleGenAI({});

async function main() {
  const response = await ai.models.generateContent({
    model: "gemini-2.5-pro",
    contents: "What is the sum of the first 50 prime numbers?",
    config: {
      thinkingConfig: {
        includeThoughts: true,
      },
    },
  });

  for (const part of response.candidates[0].content.parts) {
    if (!part.text) {
      continue;
    }
    else if (part.thought) {
      console.log("Thoughts summary:");
      console.log(part.text);
    }
    else {
      console.log("Answer:");
      console.log(part.text);
    }
  }
}

main();

Shkoni

package main

import (
  "context"
  "fmt"
  "google.golang.org/genai"
  "os"
)

func main() {
  ctx := context.Background()
  client, err := genai.NewClient(ctx, nil)
  if err != nil {
      log.Fatal(err)
  }

  contents := genai.Text("What is the sum of the first 50 prime numbers?")
  model := "gemini-2.5-pro"
  resp, _ := client.Models.GenerateContent(ctx, model, contents, &genai.GenerateContentConfig{
    ThinkingConfig: &genai.ThinkingConfig{
      IncludeThoughts: true,
    },
  })

  for _, part := range resp.Candidates[0].Content.Parts {
    if part.Text != "" {
      if part.Thought {
        fmt.Println("Thoughts Summary:")
        fmt.Println(part.Text)
      } else {
        fmt.Println("Answer:")
        fmt.Println(part.Text)
      }
    }
  }
}

Dhe këtu është një shembull duke përdorur të menduarit me transmetim, i cili kthen përmbledhje të vazhdueshme, në rritje gjatë gjenerimit:

Python

from google import genai
from google.genai import types

client = genai.Client()

prompt = """
Alice, Bob, and Carol each live in a different house on the same street: red, green, and blue.
The person who lives in the red house owns a cat.
Bob does not live in the green house.
Carol owns a dog.
The green house is to the left of the red house.
Alice does not own a cat.
Who lives in each house, and what pet do they own?
"""

thoughts = ""
answer = ""

for chunk in client.models.generate_content_stream(
    model="gemini-2.5-pro",
    contents=prompt,
    config=types.GenerateContentConfig(
      thinking_config=types.ThinkingConfig(
        include_thoughts=True
      )
    )
):
  for part in chunk.candidates[0].content.parts:
    if not part.text:
      continue
    elif part.thought:
      if not thoughts:
        print("Thoughts summary:")
      print(part.text)
      thoughts += part.text
    else:
      if not answer:
        print("Answer:")
      print(part.text)
      answer += part.text

JavaScript

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

const ai = new GoogleGenAI({});

const prompt = `Alice, Bob, and Carol each live in a different house on the same
street: red, green, and blue. The person who lives in the red house owns a cat.
Bob does not live in the green house. Carol owns a dog. The green house is to
the left of the red house. Alice does not own a cat. Who lives in each house,
and what pet do they own?`;

let thoughts = "";
let answer = "";

async function main() {
  const response = await ai.models.generateContentStream({
    model: "gemini-2.5-pro",
    contents: prompt,
    config: {
      thinkingConfig: {
        includeThoughts: true,
      },
    },
  });

  for await (const chunk of response) {
    for (const part of chunk.candidates[0].content.parts) {
      if (!part.text) {
        continue;
      } else if (part.thought) {
        if (!thoughts) {
          console.log("Thoughts summary:");
        }
        console.log(part.text);
        thoughts = thoughts + part.text;
      } else {
        if (!answer) {
          console.log("Answer:");
        }
        console.log(part.text);
        answer = answer + part.text;
      }
    }
  }
}

await main();

Shkoni

package main

import (
  "context"
  "fmt"
  "log"
  "os"
  "google.golang.org/genai"
)

const prompt = `
Alice, Bob, and Carol each live in a different house on the same street: red, green, and blue.
The person who lives in the red house owns a cat.
Bob does not live in the green house.
Carol owns a dog.
The green house is to the left of the red house.
Alice does not own a cat.
Who lives in each house, and what pet do they own?
`

func main() {
  ctx := context.Background()
  client, err := genai.NewClient(ctx, nil)
  if err != nil {
      log.Fatal(err)
  }

  contents := genai.Text(prompt)
  model := "gemini-2.5-pro"

  resp := client.Models.GenerateContentStream(ctx, model, contents, &genai.GenerateContentConfig{
    ThinkingConfig: &genai.ThinkingConfig{
      IncludeThoughts: true,
    },
  })

  for chunk := range resp {
    for _, part := range chunk.Candidates[0].Content.Parts {
      if len(part.Text) == 0 {
        continue
      }

      if part.Thought {
        fmt.Printf("Thought: %s\n", part.Text)
      } else {
        fmt.Printf("Answer: %s\n", part.Text)
      }
    }
  }
}

Nënshkrimet e mendimit

Për shkak se telefonatat standarde të tekstit të Gemini API dhe gjenerimit të përmbajtjes janë pa shtetësi, kur përdoret të menduarit në ndërveprime me shumë kthesa (siç është biseda), modeli nuk ka qasje në kontekstin e mendimit nga kthesat e mëparshme.

Ju mund të ruani kontekstin e mendimit duke përdorur nënshkrimet e mendimit, të cilat janë përfaqësime të koduara të procesit të brendshëm të mendimit të modelit. Modeli kthen nënshkrimet e mendimit në objektin e përgjigjes kur të menduarit dhe thirrja e funksionit janë të aktivizuara. Për të siguruar që modeli të ruajë kontekstin në kthesat e shumta të një bisede, duhet t'i jepni nënshkrimet e mendimit modelit në kërkesat pasuese.

Ju do të merrni nënshkrimet e mendimit kur:

Mendimi aktivizohet dhe mendimet gjenerohen.
Kërkesa përfshin deklaratat e funksionit .

Mund të gjeni një shembull të të menduarit me thirrjet e funksioneve në faqen e thirrjes së funksionit .

Kufizime të tjera të përdorimit që duhen marrë parasysh me thirrjen e funksionit përfshijnë:

Nënshkrimet kthehen nga modeli brenda pjesëve të tjera në përgjigje, për shembull thirrja e funksionit ose pjesët e tekstit. Kthejeni të gjithë përgjigjen me të gjitha pjesët përsëri në model në kthesat pasuese.
Mos i lidhni pjesët me nënshkrime së bashku.
Mos bashkoni një pjesë me një nënshkrim me një pjesë tjetër pa nënshkrim.

Çmimet

Kur të menduarit është i aktivizuar, çmimi i përgjigjes është shuma e shenjave të prodhimit dhe argumenteve të të menduarit. Ju mund të merrni numrin total të argumenteve të të menduarit të krijuar nga fusha thoughtsTokenCount .

Python

# ...
print("Thoughts tokens:",response.usage_metadata.thoughts_token_count)
print("Output tokens:",response.usage_metadata.candidates_token_count)

JavaScript

// ...
console.log(`Thoughts tokens: ${response.usageMetadata.thoughtsTokenCount}`);
console.log(`Output tokens: ${response.usageMetadata.candidatesTokenCount}`);

Shkoni

// ...
usageMetadata, err := json.MarshalIndent(response.UsageMetadata, "", "  ")
if err != nil {
  log.Fatal(err)
}
fmt.Println("Thoughts tokens:", string(usageMetadata.thoughts_token_count))
fmt.Println("Output tokens:", string(usageMetadata.candidates_token_count))

Modelet e të menduarit gjenerojnë mendime të plota për të përmirësuar cilësinë e përgjigjes përfundimtare dhe më pas nxjerrin përmbledhje për të siguruar një pasqyrë të procesit të mendimit. Pra, çmimi bazohet në argumentet e plota të mendimit që modeli duhet të gjenerojë për të krijuar një përmbledhje, pavarësisht se vetëm përmbledhja del nga API.

Mund të mësoni më shumë rreth argumenteve në udhëzuesin e numërimit të shenjave .

Modelet e mbështetura

Karakteristikat e të menduarit mbështeten në të gjitha modelet e serisë 2.5. Të gjitha aftësitë e modelit mund t'i gjeni në faqen e përmbledhjes së modelit .

Praktikat më të mira

Ky seksion përfshin disa udhëzime për përdorimin efikas të modeleve të të menduarit. Si gjithmonë, ndjekja e udhëzimeve tona nxitëse dhe praktikave më të mira do t'ju sjellë rezultatet më të mira.

Korrigjimi dhe drejtimi

Rishikoni arsyetimin : Kur nuk po merrni përgjigjen tuaj të pritur nga modelet e të menduarit, mund të ndihmojë të analizoni me kujdes përmbledhjet e mendimeve të Binjakëve. Ju mund të shihni se si e ndau detyrën dhe arriti në përfundimin e saj dhe përdorni atë informacion për të korrigjuar drejt rezultateve të duhura.
Jepni udhëzime në arsyetim : Nëse jeni duke shpresuar për një rezultat veçanërisht të gjatë, mund të dëshironi të jepni udhëzime në kërkesën tuaj për të kufizuar sasinë e të menduarit që përdor modeli. Kjo ju lejon të rezervoni më shumë nga prodhimi token për përgjigjen tuaj.

Kompleksiteti i detyrës

Detyrat e Lehta (Të menduarit mund të jetë OFF): Për kërkesat e drejtpërdrejta ku nuk kërkohet arsyetim kompleks, si marrja e fakteve ose klasifikimi, të menduarit nuk kërkohet. Shembujt përfshijnë:
- "Ku u themelua DeepMind?"
- "A është ky email që kërkon një takim apo thjesht jep informacion?"
Detyrat e mesme (Default/Disa të menduarit): Shumë kërkesa të zakonshme përfitojnë nga një shkallë e përpunimit hap pas hapi ose kuptimi më i thellë. Binjakët mund të përdorin në mënyrë fleksibël aftësinë e të menduarit për detyra si:
- Analogjizo fotosintezën dhe rritjen.
- Krahasoni dhe krahasoni makinat elektrike dhe makinat hibride.
Detyrat e vështira (Aftësia maksimale e të menduarit): Për sfida vërtet komplekse, të tilla si zgjidhja e problemeve komplekse matematikore ose detyrat e kodimit, ju rekomandojmë të vendosni një buxhet të lartë të të menduarit. Këto lloj detyrash kërkojnë që modeli të përfshijë aftësitë e tij të plota të arsyetimit dhe planifikimit, shpesh duke përfshirë shumë hapa të brendshëm përpara se të japë një përgjigje. Shembujt përfshijnë:
- Zgjidh problemin 1 në AIME 2025: Gjeni shumën e të gjitha bazave të numrave të plotë b > 9 për të cilat 17 _b është pjesëtues i 97 _b .
- Shkruani kodin Python për një aplikacion në internet që vizualizon të dhënat e tregut të aksioneve në kohë reale, duke përfshirë vërtetimin e përdoruesit. Bëjeni sa më efikase.

Të menduarit me mjete dhe aftësi

Modelet e të menduarit punojnë me të gjitha mjetet dhe aftësitë e Binjakëve. Kjo i lejon modelet të ndërveprojnë me sistemet e jashtme, të ekzekutojnë kodin ose të kenë akses në informacione në kohë reale, duke përfshirë rezultatet në arsyetimin dhe përgjigjen e tyre përfundimtare.

Mjeti i kërkimit lejon modelin të kërkojë Google Search për të gjetur informacione ose informacione të përditësuara përtej të dhënave të tij të trajnimit. Kjo është e dobishme për pyetje në lidhje me ngjarjet e fundit ose tema shumë specifike.
Mjeti i ekzekutimit të kodit i mundëson modelit të gjenerojë dhe ekzekutojë kodin Python për të kryer llogaritjet, për të manipuluar të dhënat ose për të zgjidhur problemet që trajtohen më së miri në mënyrë algoritmike. Modeli merr daljen e kodit dhe mund ta përdorë atë në përgjigjen e tij.
Me dalje të strukturuar , mund ta kufizoni Binjakët të përgjigjet me JSON. Kjo është veçanërisht e dobishme për integrimin e prodhimit të modelit në aplikacione.
Thirrja e funksionit lidh modelin e të menduarit me mjetet e jashtme dhe API-të, kështu që mund të arsyetojë se kur duhet thirrur funksioni i duhur dhe cilat parametra duhet të ofrojë.
Konteksti i URL-së i siguron modelit URL si kontekst shtesë për kërkesën tuaj. Modeli më pas mund të marrë përmbajtje nga URL-të dhe ta përdorë atë përmbajtje për të informuar dhe formësuar përgjigjen e tij.

Mund të provoni shembuj të përdorimit të mjeteve me modele të të menduarit në librin e gatimit Thinking .

Çfarë është më pas?

Për të punuar me shembuj më të thellë, si:
- Përdorimi i mjeteve me të menduarit
- Transmetimi me të menduarit
- Rregullimi i buxhetit të të menduarit për rezultate të ndryshme
dhe më shumë, provoni librin tonë të gatimit Thinking .
Mbulimi i të menduarit është tani i disponueshëm në udhëzuesin tonë të përputhshmërisë me OpenAI .
Për më shumë informacion rreth Gemini 2.5 Pro, Gemini Flash 2.5 dhe Gemini 2.5 Flash-Lite, vizitoni faqen e modelit .