Gemini 3.1 Pro API: Przewodnik Programisty z Przykładami Kodu (2026)

# Google AI Studio
model = "gemini-3.1-pro"

# Vertex AI
model = "gemini-3.1-pro@001"

pip install google-genai

from google import genai

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

response = client.models.generate_content(
    model="gemini-3.1-pro",
    contents="Explain quantum computing in 3 sentences."
)

print(response.text)

for chunk in client.models.generate_content_stream(
    model="gemini-3.1-pro",
    contents="Write a Python function to merge two sorted arrays."
):
    print(chunk.text, end="")

npm install @google/genai

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

const ai = new GoogleGenAI({ apiKey: "YOUR_API_KEY" });

const response = await ai.models.generateContent({
  model: "gemini-3.1-pro",
  contents: "Explain quantum computing in 3 sentences.",
});

console.log(response.text);

const stream = await ai.models.generateContentStream({
  model: "gemini-3.1-pro",
  contents: "Write a JavaScript function to merge two sorted arrays.",
});

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

from google import genai
from google.genai import types

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

# Define the tool
weather_tool = types.Tool(
    function_declarations=[
        types.FunctionDeclaration(
            name="get_weather",
            description="Get the current weather for a city",
            parameters=types.Schema(
                type=types.Type.OBJECT,
                properties={
                    "city": types.Schema(
                        type=types.Type.STRING,
                        description="City name, e.g. 'San Francisco'"
                    ),
                    "unit": types.Schema(
                        type=types.Type.STRING,
                        enum=["celsius", "fahrenheit"],
                        description="Temperature unit"
                    ),
                },
                required=["city"],
            ),
        )
    ]
)

# Send request with tool
response = client.models.generate_content(
    model="gemini-3.1-pro-preview-customtools",
    contents="What's the weather like in Tokyo?",
    config=types.GenerateContentConfig(
        tools=[weather_tool],
    ),
)

# Check if the model wants to call a function
for part in response.candidates[0].content.parts:
    if part.function_call:
        print(f"Function: {part.function_call.name}")
        print(f"Arguments: {part.function_call.args}")
        # Output:
        # Function: get_weather
        # Arguments: {'city': 'Tokyo', 'unit': 'celsius'}

        # In production, you'd call your actual weather API here,
        # then send the result back to Gemini for a natural language response.

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

const ai = new GoogleGenAI({ apiKey: "YOUR_API_KEY" });

const weatherTool = {
  functionDeclarations: [
    {
      name: "get_weather",
      description: "Get the current weather for a city",
      parameters: {
        type: "OBJECT",
        properties: {
          city: {
            type: "STRING",
            description: "City name, e.g. 'San Francisco'",
          },
          unit: {
            type: "STRING",
            enum: ["celsius", "fahrenheit"],
            description: "Temperature unit",
          },
        },
        required: ["city"],
      },
    },
  ],
};

const response = await ai.models.generateContent({
  model: "gemini-3.1-pro-preview-customtools",
  contents: "What's the weather like in Tokyo?",
  config: {
    tools: [weatherTool],
  },
});

// Check for function calls in the response
for (const part of response.candidates[0].content.parts) {
  if (part.functionCall) {
    console.log(`Function: ${part.functionCall.name}`);
    console.log(`Arguments:`, part.functionCall.args);
  }
}

from google import genai
from google.genai import types
import base64

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

# Read a local image
with open("screenshot.png", "rb") as f:
    image_data = f.read()

response = client.models.generate_content(
    model="gemini-3.1-pro",
    contents=[
        types.Content(
            parts=[
                types.Part(text="What's in this screenshot? Describe the UI elements."),
                types.Part(
                    inline_data=types.Blob(
                        mime_type="image/png",
                        data=image_data,
                    )
                ),
            ]
        )
    ],
)

print(response.text)

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

const ai = new GoogleGenAI({ apiKey: "YOUR_API_KEY" });

const imageData = fs.readFileSync("screenshot.png");
const base64Image = imageData.toString("base64");

const response = await ai.models.generateContent({
  model: "gemini-3.1-pro",
  contents: [
    {
      parts: [
        { text: "What's in this screenshot? Describe the UI elements." },
        {
          inlineData: {
            mimeType: "image/png",
            data: base64Image,
          },
        },
      ],
    },
  ],
});

console.log(response.text);

// In a Y Build project (Cloudflare Worker)
export async function onRequest(context) {
  const response = await fetch(
    "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.1-pro:generateContent",
    {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "x-goog-api-key": context.env.GEMINI_API_KEY,
      },
      body: JSON.stringify({
        contents: [{ parts: [{ text: "Your prompt here" }] }],
      }),
    }
  );

  const data = await response.json();
  return new Response(JSON.stringify(data));
}