Krótkie wprowadzenie do interfejsu Gemini API

Z tego przewodnika dowiesz się, jak zainstalować nasze biblioteki, wysłać pierwsze żądanie, przesyłać strumieniowo odpowiedzi, tworzyć wieloetapowe rozmowy i korzystać z narzędzi.

Żądanie do interfejsu Gemini API możesz wysłać na 2 sposoby:

  • (Zalecane) Interfejs Interactions API to nowy element podstawowy z wbudowaną obsługą wieloetapowego korzystania z narzędzi, orkiestracji i złożonych procesów rozumowania za pomocą wpisywanych kroków wykonywania. W przyszłości nowe modele wykraczające poza podstawową rodzinę modeli głównych, a także nowe funkcje i narzędzia oparte na agentach będą udostępniane wyłącznie w interfejsie Interactions API.
  • generateContent umożliwia generowanie odpowiedzi bezstanowej z modelu. Zalecamy korzystanie z interfejsu Interactions API, ale generateContent jest w pełni obsługiwany.

Ta wersja krótkiego wprowadzenia korzysta z interfejsu Interactions API do wysyłania żądań do interfejsu Gemini API.

Zanim zaczniesz

Aby korzystać z interfejsu Gemini API, musisz mieć klucz interfejsu API, który umożliwia uwierzytelnianie żądań, egzekwowanie limitów bezpieczeństwa i śledzenie wykorzystania na koncie.

Aby rozpocząć, utwórz go bezpłatnie w AI Studio:

Tworzenie klucza interfejsu Gemini API

Instalowanie pakietu Google GenAI SDK

Python

Korzystając z Pythona 3.9 lub nowszego, zainstaluj google-genai za pomocą tego polecenia pip:

pip install -q -U google-genai

JavaScript

Używając Node.js w wersji 18 lub nowszej, zainstaluj pakiet Google Gen AI SDK dla TypeScript i JavaScript za pomocą tego polecenia npm:

npm install @google/genai

Generowanie tekstu

Użyj metody interactions.create, aby wygenerować odpowiedź tekstową.

Python

from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-3.5-flash",
    input="Explain how AI works in a few words"
)

print(interaction.output_text)

JavaScript

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

const ai = new GoogleGenAI({});

async function main() {
  const interaction = await ai.interactions.create({
    model: "gemini-3.5-flash",
    input: "Explain how AI works in a few words",
  });

  console.log(interaction.output_text);
}

main();

REST

curl -X POST \
  "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H 'Content-Type: application/json' \
  -H "Api-Revision: 2026-05-20" \
  -d '{
    "model": "gemini-3.5-flash",
    "input": "Explain how AI works in a few words"
  }'

Odpowiadanie na bieżąco

Domyślnie model zwraca odpowiedź dopiero po zakończeniu całego procesu generowania. Aby uzyskać szybsze i bardziej interaktywne działanie, możesz strumieniować fragmenty odpowiedzi w miarę ich generowania.

Python

stream = client.interactions.create(
    model="gemini-3.5-flash",
    input="Explain how AI works in detail",
    stream=True
)

for event in stream:
    if event.event_type == "step.delta":
        if event.delta.type == "text":
            print(event.delta.text, end="", flush=True)

JavaScript

async function main() {
  const stream = await ai.interactions.create({
    model: "gemini-3.5-flash",
    input: "Explain how AI works in detail",
    stream: true,
  });

  for await (const event of stream) {
    if (event.event_type === "step.delta") {
      if (event.delta.type === "text") {
        process.stdout.write(event.delta.text);
      }
    }
  }
}

main();

REST

# Use alt=sse for streaming
curl -X POST \
  "https://generativelanguage.googleapis.com/v1beta/interactions?alt=sse" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H 'Content-Type: application/json' \
  -H "Api-Revision: 2026-05-20" \
  --no-buffer \
  -d '{
    "model": "gemini-3.5-flash",
    "input": "Explain how AI works in detail",
    "stream": true
  }'

Rozmowy wieloetapowe

Interfejs Gemini API ma wbudowaną obsługę tworzenia rozmów wieloetapowych. Wystarczy przekazać wartość id zwróconą z poprzedniej interakcji jako parametr previous_interaction_id, a serwer automatycznie zarządza historią rozmów.

Python


interaction1 = client.interactions.create(
    model="gemini-3.5-flash",
    input="I have 2 dogs in my house."
)
print("Response 1:", interaction1.output_text)

interaction2 = client.interactions.create(
    model="gemini-3.5-flash",
    input="How many paws are in my house?",
    previous_interaction_id=interaction1.id
)
print("Response 2:", interaction2.output_text)

JavaScript

async function main() {
  const interaction1 = await ai.interactions.create({
    model: "gemini-3-flash-preview",
    input: "I have 2 dogs in my house.",
  });
  console.log("Response 1:", interaction1.output_text);

  const interaction2 = await ai.interactions.create({
    model: "gemini-3-flash-preview",
    input: "How many paws are in my house?",
    previous_interaction_id: interaction1.id,
  });
  console.log("Response 2:", interaction2.output_text);
}

main();

REST

# Turn 1: Start the conversation
RESPONSE1=$(curl -s -X POST \
  "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "Api-Revision: 2026-05-20" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "gemini-3-flash-preview",
    "input": "I have 2 dogs in my house."
  }')

# Extract the interaction ID
INTERACTION_ID=$(echo "$RESPONSE1" | jq -r '.id')

# Turn 2: Continue the conversation
curl -X POST \
  "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "Api-Revision: 2026-05-20" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H 'Content-Type: application/json' \
  -d "{
    \"model\": \"gemini-3-flash-preview\",
    \"input\": \"How many paws are in my house?\",
    \"previous_interaction_id\": \"$INTERACTION_ID\"
  }"

Korzystanie z narzędzi

Rozszerz możliwości modelu, uzyskując dostęp do informacji z wyszukiwarki Google, aby korzystać z treści internetowych w czasie rzeczywistym. Model automatycznie decyduje, kiedy wyszukiwać informacje, wykonuje zapytania i syntetyzuje odpowiedź z cytatami.

Poniższy przykład pokazuje, jak włączyć wyszukiwarkę Google:

Python

interaction = client.interactions.create(
    model="gemini-3-flash-preview",
    input="Who won the euro 2024?",
    tools=[{"type": "google_search"}]
)

print(interaction.output_text)

for step in interaction.steps:
    if step.type == "model_output":
        for content_block in step.content:
            if content_block.type == "text" and content_block.annotations:
                print("\nCitations:")
                for annotation in content_block.annotations:
                    if annotation.type == "url_citation":
                        print(f"  - [{annotation.title}]({annotation.url})")

JavaScript

async function main() {
  const interaction = await ai.interactions.create({
    model: "gemini-3-flash-preview",
    input: "Who won the euro 2024?",
    tools: [{ type: "google_search" }]
  });

  console.log(interaction.output_text);

  for (const step of interaction.steps) {
    if (step.type === 'model_output') {
      for (const contentBlock of step.content) {
        if (contentBlock.type === 'text' && contentBlock.annotations) {
          console.log("\nCitations:");
          for (const annotation of contentBlock.annotations) {
            if (annotation.type === 'url_citation') {
              console.log(`  - [${annotation.title}](${annotation.url})`);
            }
          }
        }
      }
    }
  }
}

main();

REST

curl -X POST \
  "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "Api-Revision: 2026-05-20" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-3-flash-preview",
    "input": "Who won the euro 2024?",
    "tools": [{"type": "google_search"}]
  }'

Gemini API obsługuje też inne wbudowane narzędzia:

  • Wykonywanie kodu: pozwala modelowi pisać i uruchamiać kod w Pythonie w celu rozwiązywania złożonych problemów matematycznych.
  • Kontekst URL: umożliwia oparcie odpowiedzi na konkretnych adresach URL stron internetowych, które podasz.
  • Wyszukiwanie plików: umożliwia przesyłanie plików i uzyskiwanie odpowiedzi na podstawie ich zawartości za pomocą wyszukiwania semantycznego.
  • Mapy Google: umożliwiają oparcie odpowiedzi na danych o lokalizacji oraz wyszukiwanie miejsc, tras i map.
  • Korzystanie z komputera: umożliwia modelowi interakcję z wirtualnym ekranem komputera, klawiaturą i myszą w celu wykonywania zadań.

Wywoływanie funkcji niestandardowych

Używaj wywoływania funkcji, aby łączyć modele z własnymi narzędziami i interfejsami API. Model określa, kiedy wywołać funkcję, i zwraca krok function_call z argumentami, które aplikacja ma wykonać.

W tym przykładzie deklarujemy funkcję symulującą temperaturę i sprawdzamy, czy model chce ją wywołać.

Python

import json

weather_function = {
    "type": "function",
    "name": "get_current_temperature",
    "description": "Gets the current temperature for a given location.",
    "parameters": {
        "type": "object",
        "properties": {
            "location": {
                "type": "string",
                "description": "The city name, e.g. San Francisco",
            },
        },
        "required": ["location"],
    },
}

interaction = client.interactions.create(
    model="gemini-3-flash-preview",
    input="What's the temperature in London?",
    tools=[weather_function],
)

fc_step = None
for step in interaction.steps:
    if step.type == "function_call":
        fc_step = step
        break

if fc_step:
    print(f"Model requested function: {fc_step.name} with args {fc_step.arguments}")

    mock_result = {"temperature": "15C", "condition": "Cloudy"}

    final_interaction = client.interactions.create(
        model="gemini-3-flash-preview",
        input=[
            {
                "type": "function_result",
                "name": fc_step.name,
                "call_id": fc_step.id,
                "result": [{"type": "text", "text": json.dumps(mock_result)}],
            }
        ],
        tools=[weather_function],
        previous_interaction_id=interaction.id,
    )
    print("Final Response:", final_interaction.output_text)

JavaScript

async function main() {
  const weatherFunction = {
    type: 'function',
    name: 'get_current_temperature',
    description: 'Gets the current temperature for a given location.',
    parameters: {
      type: 'object',
      properties: {
        location: {
          type: 'string',
          description: 'The city name, e.g. San Francisco',
        },
      },
      required: ['location'],
    },
  };

  const interaction = await ai.interactions.create({
    model: 'gemini-3-flash-preview',
    input: "What's the temperature in London?",
    tools: [weatherFunction],
  });

  const fcStep = interaction.steps.find(s => s.type === 'function_call');
  if (fcStep) {
    console.log(`Model requested function: ${fcStep.name}`);

    const mockResult = { temperature: "15C", condition: "Cloudy" };

    const finalInteraction = await ai.interactions.create({
      model: 'gemini-3-flash-preview',
      input: [{
        type: 'function_result',
        name: fcStep.name,
        call_id: fcStep.id,
        result: [{ type: 'text', text: JSON.stringify(mockResult) }]
      }],
      tools: [weatherFunction],
      previous_interaction_id: interaction.id,
    });

    console.log("Final Response:", finalInteraction.output_text);
  }
}

main();

REST

curl -X POST \
  "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "Api-Revision: 2026-05-20" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-3-flash-preview",
    "input": "What'\''s the temperature in London?",
    "tools": [{
      "type": "function",
      "name": "get_current_temperature",
      "description": "Gets the current temperature for a given location.",
      "parameters": {
        "type": "object",
        "properties": {
          "location": {"type": "string", "description": "The city name"}
        },
        "required": ["location"]
      }
    }]
  }'

Co dalej?

Teraz, gdy już wiesz, jak zacząć korzystać z interfejsu Gemini API, zapoznaj się z tymi przewodnikami, aby tworzyć bardziej zaawansowane aplikacje: