Gjenerimi i tekstit

Gemini API mund të gjenerojë dalje teksti në përgjigje të hyrjeve të ndryshme, duke përfshirë tekstin, imazhet, videon dhe audion. Ky udhëzues ju tregon se si të gjeneroni tekst duke përdorur të dhëna teksti dhe imazhi. Ai gjithashtu mbulon transmetimin, bisedën dhe udhëzimet e sistemit.

Futja e tekstit

Mënyra më e thjeshtë për të gjeneruar tekst duke përdorur Gemini API është t'i siguroni modelit një hyrje të vetme vetëm teksti, siç tregohet në këtë shembull:

Python JavaScript Shkoni PUSHIMI 
from google import genai

client = genai.Client(api_key="GEMINI_API_KEY")

response = client.models.generate_content(
    model="gemini-2.0-flash",
    contents=["How does AI work?"]
)
print(response.text)

import { GoogleGenerativeAI } from "@google/generative-ai";

async function main() {
  const genAI = new GoogleGenerativeAI("GEMINI_API_KEY");
  const model = genAI.getGenerativeModel({ model: "gemini-2.0-flash" });
  const prompt = "How does AI work?";

  const result = await model.generateContent(prompt);
  console.log(result.response.text());
}
main();

// import packages here

func main() {
  ctx := context.Background()
  client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("GEMINI_API_KEY")))
  if err != nil {
    log.Fatal(err)
  }
  defer client.Close()

  model := client.GenerativeModel("gemini-2.0-flash")
  resp, err := model.GenerateContent(ctx, genai.Text("How does AI work?"))
  if err != nil {
    log.Fatal(err)
  }
  printResponse(resp) // helper function for printing content parts
}

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GEMINI_API_KEY" \
-H 'Content-Type: application/json' \
-X POST \
-d '{
  "contents": [{
    "parts":[{"text": "How does AI work?"}]
    }]
   }' 2> /dev/null

Hyrja e imazhit

Gemini API mbështet hyrjet multimodale që kombinojnë skedarët tekst dhe media. Shembulli i mëposhtëm tregon se si të gjeneroni tekst nga futja e tekstit dhe imazhit:

Python JavaScript Shkoni PUSHIMI 
from PIL import Image
from google import genai

client = genai.Client(api_key="GEMINI_API_KEY")

image = Image.open("/path/to/organ.png")
response = client.models.generate_content(
    model="gemini-2.0-flash",
    contents=[image, "Tell me about this instrument"]
)
print(response.text)

import { GoogleGenerativeAI } from "@google/generative-ai";
import * as fs from 'node:fs';

const genAI = new GoogleGenerativeAI("GEMINI_API_KEY");
const model = genAI.getGenerativeModel({ model: "gemini-2.0-flash" });

function fileToGenerativePart(path, mimeType) {
  return {
    inlineData: {
      data: Buffer.from(fs.readFileSync(path)).toString("base64"),
      mimeType,
    },
  };
}

const prompt = "Describe how this product might be manufactured.";
const imagePart = fileToGenerativePart("/path/to/image.png", "image/png");

const result = await model.generateContent([prompt, imagePart]);
console.log(result.response.text());

model := client.GenerativeModel("gemini-2.0-flash")

imgData, err := os.ReadFile(filepath.Join(testDataDir, "organ.jpg"))
if err != nil {
  log.Fatal(err)
}

resp, err := model.GenerateContent(ctx,
  genai.Text("Tell me about this instrument"),
  genai.ImageData("jpeg", imgData))
if err != nil {
  log.Fatal(err)
}

printResponse(resp)

# Use a temporary file to hold the base64 encoded image data
TEMP_B64=$(mktemp)
trap 'rm -f "$TEMP_B64"' EXIT
base64 $B64FLAGS $IMG_PATH > "$TEMP_B64"

# Use a temporary file to hold the JSON payload
TEMP_JSON=$(mktemp)
trap 'rm -f "$TEMP_JSON"' EXIT

cat > "$TEMP_JSON" << EOF
{
  "contents": [{
    "parts":[
      {"text": "Tell me about this instrument"},
      {
        "inline_data": {
          "mime_type":"image/jpeg",
          "data": "$(cat "$TEMP_B64")"
        }
      }
    ]
  }]
}
EOF

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GEMINI_API_KEY" \
    -H 'Content-Type: application/json' \
    -X POST \
    -d "@$TEMP_JSON" 2> /dev/null

Prodhimi i transmetimit

Si parazgjedhje, modeli kthen një përgjigje pasi të ketë përfunduar të gjithë procesin e krijimit të tekstit. Mund të arrini ndërveprime më të shpejta duke përdorur transmetimin për të kthyer instancat e GenerateContentResponse ndërsa ato krijohen.

Python JavaScript Shkoni PUSHIMI 
from google import genai

client = genai.Client(api_key="GEMINI_API_KEY")

response = client.models.generate_content_stream(
    model="gemini-2.0-flash",
    contents=["Explain how AI works"]
)
for chunk in response:
    print(chunk.text, end="")

import { GoogleGenerativeAI } from "@google/generative-ai";
const genAI = new GoogleGenerativeAI("GEMINI_API_KEY");
const model = genAI.getGenerativeModel({ model: "gemini-1.5-flash" });

const prompt = "Explain how AI works";

const result = await model.generateContentStream(prompt);

for await (const chunk of result.stream) {
  const chunkText = chunk.text();
  process.stdout.write(chunkText);
}

model := client.GenerativeModel("gemini-1.5-flash")
iter := model.GenerateContentStream(ctx, genai.Text("Write a story about a magic backpack."))
for {
  resp, err := iter.Next()
  if err == iterator.Done {
    break
  }
  if err != nil {
    log.Fatal(err)
  }
  printResponse(resp)
}

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:streamGenerateContent?alt=sse&key=${GEMINI_API_KEY}" \
    -H 'Content-Type: application/json' \
    --no-buffer \
    -d '{ "contents":[{"parts":[{"text": "Write a story about a magic backpack."}]}]}'

Biseda me shumë kthesa

Gemini SDK ju lejon të grumbulloni raunde të shumta pyetjesh dhe përgjigjesh në një bisedë. Formati i bisedës u mundëson përdoruesve të hapin hap pas hapi drejt përgjigjeve dhe të marrin ndihmë për problemet me shumë pjesë. Ky implementim i SDK-së i bisedës ofron një ndërfaqe për të mbajtur gjurmët e historisë së bisedave, por në prapaskenë ai përdor të njëjtën metodë generateContent për të krijuar përgjigjen.

Shembulli i mëposhtëm i kodit tregon një zbatim bazë të bisedës:

Python JavaScript Shkoni PUSHIMI 
from google import genai

client = genai.Client(api_key="GEMINI_API_KEY")
chat = client.chats.create(model="gemini-2.0-flash")

response = chat.send_message("I have 2 dogs in my house.")
print(response.text)

response = chat.send_message("How many paws are in my house?")
print(response.text)

for message in chat.get_history():
    print(f'role - {message.role}',end=": ")
    print(message.parts[0].text)

import { GoogleGenerativeAI } from "@google/generative-ai";
const genAI = new GoogleGenerativeAI("GEMINI_API_KEY");
const model = genAI.getGenerativeModel({ model: "gemini-1.5-flash" });
const chat = model.startChat({
  history: [
    {
      role: "user",
      parts: [{ text: "Hello" }],
    },
    {
      role: "model",
      parts: [{ text: "Great to meet you. What would you like to know?" }],
    },
  ],
});

let result = await chat.sendMessage("I have 2 dogs in my house.");
console.log(result.response.text());
let result2 = await chat.sendMessage("How many paws are in my house?");
console.log(result2.response.text());

model := client.GenerativeModel("gemini-1.5-flash")
cs := model.StartChat()

cs.History = []*genai.Content{
  {
    Parts: []genai.Part{
      genai.Text("Hello, I have 2 dogs in my house."),
    },
    Role: "user",
  },
  {
    Parts: []genai.Part{
      genai.Text("Great to meet you. What would you like to know?"),
    },
    Role: "model",
  },
}

res, err := cs.SendMessage(ctx, genai.Text("How many paws are in my house?"))
if err != nil {
  log.Fatal(err)
}
printResponse(res)

curl https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GEMINI_API_KEY \
-H 'Content-Type: application/json' \
-X POST \
-d '{
  "contents": [
    {"role":"user",
     "parts":[{
       "text": "Hello"}]},
    {"role": "model",
     "parts":[{
       "text": "Great to meet you. What would you like to know?"}]},
    {"role":"user",
     "parts":[{
       "text": "I have two dogs in my house. How many paws are in my house?"}]},
  ]
}' 2> /dev/null | grep "text"

Ju gjithashtu mund të përdorni transmetimin me chat, siç tregohet në shembullin e mëposhtëm:

Python JavaScript Shkoni PUSHIMI 
from google import genai

client = genai.Client(api_key="GEMINI_API_KEY")
chat = client.chats.create(model="gemini-2.0-flash")

response = chat.send_message_stream("I have 2 dogs in my house.")
for chunk in response:
    print(chunk.text, end="")

response = chat.send_message_stream("How many paws are in my house?")
for chunk in response:
    print(chunk.text, end="")

for message in chat.get_history():
    print(f'role - {message.role}', end=": ")
    print(message.parts[0].text)

import { GoogleGenerativeAI } from "@google/generative-ai";
const genAI = new GoogleGenerativeAI("GEMINI_API_KEY");
const model = genAI.getGenerativeModel({ model: "gemini-1.5-flash" });

const chat = model.startChat({
  history: [
    {
      role: "user",
      parts: [{ text: "Hello" }],
    },
    {
      role: "model",
      parts: [{ text: "Great to meet you. What would you like to know?" }],
    },
  ],
});

let result = await chat.sendMessageStream("I have 2 dogs in my house.");
for await (const chunk of result.stream) {
  const chunkText = chunk.text();
  process.stdout.write(chunkText);
}
let result2 = await chat.sendMessageStream("How many paws are in my house?");
for await (const chunk of result2.stream) {
  const chunkText = chunk.text();
  process.stdout.write(chunkText);
}

model := client.GenerativeModel("gemini-1.5-flash")
cs := model.StartChat()

cs.History = []*genai.Content{
  {
    Parts: []genai.Part{
      genai.Text("Hello, I have 2 dogs in my house."),
    },
    Role: "user",
  },
  {
    Parts: []genai.Part{
      genai.Text("Great to meet you. What would you like to know?"),
    },
    Role: "model",
  },
}

iter := cs.SendMessageStream(ctx, genai.Text("How many paws are in my house?"))
for {
  resp, err := iter.Next()
  if err == iterator.Done {
    break
  }
  if err != nil {
    log.Fatal(err)
  }
  printResponse(resp)
}

curl https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:streamGenerateContent?alt=sse&key=$GEMINI_API_KEY \
-H 'Content-Type: application/json' \
-X POST \
-d '{
  "contents": [
    {"role":"user",
     "parts":[{
       "text": "Hello"}]},
    {"role": "model",
     "parts":[{
       "text": "Great to meet you. What would you like to know?"}]},
    {"role":"user",
     "parts":[{
       "text": "I have two dogs in my house. How many paws are in my house?"}]},
  ]
}' 2> /dev/null | grep "text"

Parametrat e konfigurimit

Çdo kërkesë që i dërgoni modelit përfshin parametra që kontrollojnë se si modeli gjeneron përgjigje. Ju mund t'i konfiguroni këto parametra ose ta lini modelin të përdorë opsionet e paracaktuara.

Shembulli i mëposhtëm tregon se si të konfiguroni parametrat e modelit:

Python JavaScript Shkoni PUSHIMI 
from google import genai
from google.genai import types

client = genai.Client(api_key="GEMINI_API_KEY")

response = client.models.generate_content(
    model="gemini-2.0-flash",
    contents=["Explain how AI works"],
    config=types.GenerateContentConfig(
        max_output_tokens=500,
        temperature=0.1
    )
)
print(response.text)

import { GoogleGenerativeAI } from "@google/generative-ai";
const genAI = new GoogleGenerativeAI("GEMINI_API_KEY");

const model = genAI.getGenerativeModel({ model: "gemini-1.5-flash" });

const result = await model.generateContent({
    contents: [
        {
          role: 'user',
          parts: [
            {
              text: "Explain how AI works",
            }
          ],
        }
    ],
    generationConfig: {
      maxOutputTokens: 1000,
      temperature: 0.1,
    }
});

console.log(result.response.text());

model := client.GenerativeModel("gemini-1.5-pro-latest")
model.SetTemperature(0.9)
model.SetTopP(0.5)
model.SetTopK(20)
model.SetMaxOutputTokens(100)
model.SystemInstruction = genai.NewUserContent(genai.Text("You are Yoda from Star Wars."))
model.ResponseMIMEType = "application/json"
resp, err := model.GenerateContent(ctx, genai.Text("What is the average size of a swallow?"))
if err != nil {
  log.Fatal(err)
}
printResponse(resp)

curl https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GEMINI_API_KEY \
-H 'Content-Type: application/json' \
-X POST \
-d '{
    "contents": [{
        "parts":[
            {"text": "Explain how AI works"}
        ]
    }],
    "generationConfig": {
        "stopSequences": [
            "Title"
        ],
        "temperature": 1.0,
        "maxOutputTokens": 800,
        "topP": 0.8,
        "topK": 10
    }
}'  2> /dev/null | grep "text"

Këtu janë disa nga parametrat e modelit që mund të konfiguroni. (Konventat e emërtimit ndryshojnë sipas gjuhës së programimit.)

  • stopSequences : Përcakton grupin e sekuencave të karaktereve (deri në 5) që do të ndalojnë gjenerimin e daljes. Nëse specifikohet, API do të ndalojë në shfaqjen e parë të një stop_sequence . Sekuenca e ndalimit nuk do të përfshihet si pjesë e përgjigjes.
  • temperature : Kontrollon rastësinë e daljes. Përdorni vlera më të larta për përgjigje më kreative dhe vlera më të ulëta për përgjigje më deterministe. Vlerat mund të variojnë nga [0.0, 2.0].
  • maxOutputTokens : Vendos numrin maksimal të argumenteve për t'u përfshirë në një kandidat.
  • topP : Ndryshon mënyrën se si modeli zgjedh argumentet për dalje. Shenjat zgjidhen nga më e mundshme në më pak të mundshme derisa shuma e probabiliteteve të tyre të jetë e barabartë me vlerën topP . Vlera e paracaktuar topP është 0.95.
  • topK : Ndryshon mënyrën se si modeli zgjedh argumentet për dalje. Një topK prej 1 do të thotë se tokeni i zgjedhur është më i mundshmi nga të gjithë shenjat në fjalorin e modelit, ndërsa një topK prej 3 do të thotë që tokeni tjetër zgjidhet nga 3 më të mundshmit duke përdorur temperaturën. Shenjat filtrohen më tej në bazë të topP me shenjën përfundimtare të zgjedhur duke përdorur kampionimin e temperaturës.

Udhëzimet e sistemit

Udhëzimet e sistemit ju lejojnë të drejtoni sjelljen e një modeli bazuar në rastin tuaj specifik të përdorimit. Kur jepni udhëzime të sistemit, i jepni modelit kontekst shtesë për ta ndihmuar atë të kuptojë detyrën dhe të gjenerojë përgjigje më të personalizuara. Modeli duhet t'u përmbahet udhëzimeve të sistemit gjatë ndërveprimit të plotë me përdoruesin, duke ju mundësuar të specifikoni sjelljen e nivelit të produktit të ndarë nga kërkesat e ofruara nga përdoruesit përfundimtarë.

Ju mund të vendosni udhëzimet e sistemit kur inicializoni modelin tuaj:

Python JavaScript Shkoni PUSHIMI 
from google import genai
from google.genai import types

client = genai.Client(api_key="GEMINI_API_KEY")

response = client.models.generate_content(
    model="gemini-2.0-flash",
    config=types.GenerateContentConfig(
        system_instruction="You are a cat. Your name is Neko."),
    contents="Hello there"
)

print(response.text)

import { GoogleGenerativeAI } from "@google/generative-ai";

async function main() {
  const genAI = new GoogleGenerativeAI("GEMINI_API_KEY");
  const model = genAI.getGenerativeModel({
      model: "gemini-2.0-flash",
      systemInstruction: "You are a cat. Your name is Neko.",
  });
  const prompt = "Hello there";

  const result = await model.generateContent(prompt);
  console.log(result.response.text());
}

main();

// import packages here

func main() {
  ctx := context.Background()
  client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("GEMINI_API_KEY")))
  if err != nil {
    log.Fatal(err)
  }
  defer client.Close()

  model := client.GenerativeModel("gemini-2.0-flash")
  model.SystemInstruction = &genai.Content{
    Parts: []genai.Part{genai.Text(`
      You are a cat. Your name is Neko.
    `)},
  }
  resp, err := model.GenerateContent(ctx, genai.Text("Hello there"))
  if err != nil {
    log.Fatal(err)
  }
  printResponse(resp) // helper function for printing content parts
}

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GEMINI_API_KEY" \
-H 'Content-Type: application/json' \
-d '{ "system_instruction": {
    "parts":
      { "text": "You are a cat. Your name is Neko."}},
    "contents": {
      "parts": {
        "text": "Hello there"}}}'

Më pas, mund t'i dërgoni kërkesa modelit si zakonisht.

Modelet e mbështetura

E gjithë familja e modeleve Gemini mbështet gjenerimin e tekstit. Për të mësuar më shumë rreth modeleve dhe aftësive të tyre, shihni Modelet .

Këshilla nxitëse

Për rastet bazë të përdorimit të gjenerimit të tekstit, kërkesa juaj mund të mos ketë nevojë të përfshijë ndonjë shembull daljeje, udhëzime sistemi ose informacion formatimi. Kjo është një qasje zero-shot . Për disa raste përdorimi, një kërkesë me një shkrepje ose me disa shkrepje mund të prodhojë rezultate që përputhet më shumë me pritjet e përdoruesit. Në disa raste, mund të dëshironi të jepni gjithashtu udhëzime të sistemit për të ndihmuar modelin të kuptojë detyrën ose të ndjekë udhëzime specifike.

Çfarë është më pas