Gemini 2.5 Pro для AI-агентов: Google AI Studio, SDK

Gemini 2.5 Pro для AI-агентов: Google AI Studio, Python SDK, инструменты | QantCore

♊

Gemini 2.5 Pro для AI-агентов: Google AI Studio, Python SDK, инструменты

Полный гайд по созданию AI-агентов на Gemini 2.5 Pro — миллионный контекст, нативные function calling, Google Search grounding, code execution и мультимодальность. Практические примеры с google-genai SDK, LangChain и Vertex AI.

intermediate ⏱ 20 мин

1. Установка и настройка: Google AI Studio, API-ключ, google-genai SDK

Gemini 2.5 Pro — флагманская мультимодальная модель Google с контекстным окном до 1 миллиона токенов и нативной поддержкой вызова функций. Для создания агентов мы используем официальный Python SDK google-genai, который предоставляет прямой доступ ко всем возможностям модели, включая function calling, code execution, Google Search grounding и стриминг ответов. В этой секции мы пройдём полный путь от регистрации до первого успешного запроса.

⚡ Ключевое преимущество: Gemini 2.5 Pro — единственная модель на рынке, которая объединяет миллионный контекст, нативный function calling и встроенный Google Search без необходимости подключать сторонние API. Это радикально упрощает архитектуру агента.

Шаг 1. Получение API-ключа в Google AI Studio

Google AI Studio — это бесплатная веб-среда для прототипирования запросов к моделям Gemini. Чтобы получить ключ:

Перейдите на aistudio.google.com и войдите с Google-аккаунтом.
В левом боковом меню нажмите «Get API key».
Нажмите «Create API key» и выберите проект Google Cloud (можно создать новый).
Скопируйте сгенерированный ключ — он понадобится для аутентификации.

Бесплатная квота (free tier) включает до 1 500 запросов в день для Gemini 2.5 Pro и до 100 запросов в день для Gemini 2.5 Flash — для обучения и прототипирования этого более чем достаточно.

Шаг 2. Установка google-genai SDK

Официальный Python SDK устанавливается через pip одной командой. Рекомендуется использовать виртуальное окружение:

# Создаём виртуальное окружение
python3 -m venv gemini-agent-env
source gemini-agent-env/bin/activate

# Устанавливаем google-genai SDK
pip install google-genai

# Для LangChain-интеграции (понадобится в секции 6)
pip install langchain-google-genai langchain

💡 Совет: SDK google-genai — это новый, переписанный с нуля клиент (v1+). Старый google-generativeai всё ещё работает, но новый SDK быстрее, имеет лучшую поддержку стриминга и типизацию. Используйте именно google-genai.

Шаг 3. Конфигурация клиента и первый запрос

Создайте файл .env для хранения ключа и напишите скрипт инициализации:

# .env
GEMINI_API_KEY="ваш-ключ-из-ai-studio"

import os
from google import genai
from dotenv import load_dotenv

load_dotenv()

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

# Проверяем соединение — простой вопрос
response = client.models.generate_content(
    model="gemini-2.5-pro-exp-03-25",
    contents="Привет! Ты готов работать как AI-агент?"
)

print(response.text)

Модель gemini-2.5-pro-exp-03-25 — актуальный идентификатор Gemini 2.5 Pro на момент написания гайда. Полный список доступных моделей можно получить программно:

for m in client.models.list():
    if "gemini" in m.name:
        print(m.name)

Теперь у вас есть полностью настроенный клиент, готовый к построению агентов. Двигаемся дальше — к реальному function calling.

2. Базовый агент с function calling на Gemini (поиск, калькулятор)

Function calling (вызов функций) — ключевой механизм, превращающий языковую модель в агента. Gemini не вызывает функции сам — он возвращает структурированный JSON с именем функции и аргументами, а ваш код выполняет вызов и возвращает результат обратно модели. Такая архитектура называется «цикл агента» (agent loop).

Создадим агента с двумя инструментами: поиск по локальной базе знаний и калькулятор. Модель будет сама решать, какой инструмент применить, и может комбинировать их в многошаговых цепочках.

Определение функций (tool declarations)

import json
import math

# Локальная «база знаний» — словарь с фактами
knowledge_base = {
    "python": "Python — высокоуровневый язык программирования, созданный Гвидо ван Россумом в 1991 году.",
    "gemini": "Gemini 2.5 Pro — мультимодальная LLM от Google DeepMind с контекстом до 1M токенов.",
    "langchain": "LangChain — фреймворк для создания приложений на базе LLM с цепочками и агентами.",
    "agent": "AI-агент — автономная система, использующая LLM для планирования и выполнения задач с инструментами.",
}

def search_knowledge_base(query: str) -> str:
    """Поиск по локальной базе знаний. Возвращает релевантную статью."""
    query_lower = query.lower()
    for key, value in knowledge_base.items():
        if key in query_lower:
            return value
    return "Информация по запросу не найдена."

def calculator(operation: str, a: float, b: float) -> str:
    """Калькулятор. Поддерживает add, subtract, multiply, divide, power."""
    ops = {
        "add": a + b,
        "subtract": a - b,
        "multiply": a * b,
        "divide": a / b if b != 0 else "Ошибка: деление на ноль",
        "power": math.pow(a, b),
    }
    result = ops.get(operation, "Неизвестная операция")
    return f"Результат {operation}({a}, {b}) = {result}"

Декларации инструментов для Gemini

Gemini принимает описание функций в специальном формате. Важно указать name, description и parameters в виде JSON Schema:

# Конфигурация инструментов для Gemini
tool_config = {
    "function_declarations": [
        {
            "name": "search_knowledge_base",
            "description": "Поиск информации по ключевым словам в базе знаний. Используй для ответа на фактологические вопросы о Python, Gemini, LangChain, AI-агентах.",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {
                        "type": "string",
                        "description": "Поисковый запрос (ключевое слово)"
                    }
                },
                "required": ["query"]
            }
        },
        {
            "name": "calculator",
            "description": "Выполняет математические операции. Используй для любых вычислений.",
            "parameters": {
                "type": "object",
                "properties": {
                    "operation": {
                        "type": "string",
                        "enum": ["add", "subtract", "multiply", "divide", "power"]
                    },
                    "a": {"type": "number", "description": "Первый операнд"},
                    "b": {"type": "number", "description": "Второй операнд"}
                },
                "required": ["operation", "a", "b"]
            }
        }
    ]
}

Цикл агента (Agent Loop)

Сердце агента — цикл, который отправляет запрос модели, получает либо текстовый ответ, либо вызов функции, выполняет функцию и отправляет результат обратно. Цикл продолжается до тех пор, пока модель не вернёт финальный текстовый ответ:

import json

def run_agent(user_query: str, max_turns: int = 5) -> str:
    """Запускает агента Gemini с циклом function calling."""

    # Сопоставление имён функций с реальными Python-функциями
    available_functions = {
        "search_knowledge_base": search_knowledge_base,
        "calculator": calculator,
    }

    # Системный промпт, задающий поведение агента
    system_instruction = (
        "Ты — полезный AI-агент с доступом к базе знаний и калькулятору. "
        "Всегда используй инструменты, когда это уместно. "
        "Отвечай на русском языке."
    )

    # Начальное сообщение
    contents = [user_query]

    for turn in range(max_turns):
        print(f"\n--- Ход {turn + 1} ---")

        response = client.models.generate_content(
            model="gemini-2.5-pro-exp-03-25",
            contents=contents,
            config={
                "system_instruction": system_instruction,
                "tools": tool_config,
            }
        )

        # Проверяем, есть ли function call в ответе
        part = response.candidates[0].content.parts[0]

        if part.function_call is not None:
            # Модель хочет вызвать функцию
            fn_call = part.function_call
            fn_name = fn_call.name
            fn_args = dict(fn_call.args)

            print(f"🔧 Вызов функции: {fn_name}({fn_args})")

            # Выполняем функцию
            if fn_name in available_functions:
                result = available_functions[fn_name](**fn_args)
            else:
                result = f"Функция '{fn_name}' не найдена."

            print(f"📋 Результат: {result}")

            # Добавляем результат функции в историю диалога
            contents.append({
                "role": "model",
                "parts": [{"function_call": fn_call}]
            })
            contents.append({
                "role": "user",
                "parts": [{
                    "function_response": {
                        "name": fn_name,
                        "response": {"result": result}
                    }
                }]
            })
            continue  # Следующая итерация — модель получит результат

        else:
            # Модель вернула финальный текстовый ответ
            final_answer = response.text
            print(f"✅ Финальный ответ:\n{final_answer}")
            return final_answer

    return "⚠️ Достигнут лимит ходов агента."

# Пример использования
run_agent("Расскажи про Gemini и посчитай 2 в степени 10 плюс 500.")

🔍 Что происходит под капотом: На первом ходе модель получает запрос пользователя и решает, что нужны два вызова — сначала search_knowledge_base("gemini"), затем calculator("power", 2, 10). Gemini может запрашивать несколько функций параллельно (multi-tool calling) или последовательно, в зависимости от логики задачи. Цикл агента гарантирует, что каждый вызов будет выполнен, а результат вернётся модели для формирования итогового ответа.

Параллельный вызов нескольких функций

Gemini 2.5 Pro поддерживает параллельный function calling — модель может запросить несколько функций в одном ответе, если они независимы. Это ускоряет работу агента. Обработка параллельных вызовов:

# В ответе может быть несколько part с function_call
if response.candidates[0].content.parts:
    for part in response.candidates[0].content.parts:
        if part.function_call is not None:
            # Обрабатываем каждый вызов
            fn_call = part.function_call
            print(f"Параллельный вызов: {fn_call.name}")

Теперь у нас есть полноценный агент с двумя инструментами. В следующей секции мы подключим гораздо более мощный инструмент — Google Search.

3. Google Search Grounding — агент с поиском в реальном времени

Google Search Grounding — одна из самых мощных и уникальных возможностей Gemini. В отличие от обычного function calling, где вы должны реализовать поисковый API (SerpAPI, Brave Search и т.д.), Gemini нативно обращается к Google Search и возвращает не только ответ, но и источники (grounding sources) с ссылками. Это критически важно для агентов, которым нужна актуальная информация: новости, цены, факты после даты отсечки модели.

🌐 Важно: Google Search Grounding доступен только для моделей Gemini через Google AI Studio или Vertex AI. Это не отдельный API и не требует дополнительной платы сверх обычной стоимости токенов (для платных тарифов). Во free tier поисковые запросы ограничены квотой в 100 штук в день.

Включение Google Search через google_search инструмент

Для активации Google Search grounding нужно передать специальную конфигурацию инструментов при вызове модели:

from google import genai
from google.genai.types import (
    GenerateContentConfig,
    GoogleSearch,
    Tool,
)

# Создаём инструмент Google Search
google_search_tool = Tool(
    google_search=GoogleSearch()
)

# Запрос с автоматическим поиском
response = client.models.generate_content(
    model="gemini-2.5-pro-exp-03-25",
    contents="Какая сейчас цена Bitcoin и какие были главные новости криптовалют за последнюю неделю?",
    config=GenerateContentConfig(
        tools=[google_search_tool],
        system_instruction="Ты — финансовый AI-агент. Всегда указывай источники информации.",
    ),
)

# Вывод ответа
print("Ответ агента:")
print(response.text)

# Извлекаем источники (grounding sources)
if response.candidates[0].grounding_metadata:
    metadata = response.candidates[0].grounding_metadata
    print("\n📎 Источники:")
    for chunk in metadata.grounding_chunks:
        if chunk.web:
            print(f"  • {chunk.web.title}: {chunk.web.uri}")

Агент с гибридным поиском: function calling + Google Search

Реальная сила раскрывается при комбинировании: агент использует Google Search для актуальной информации, а function calling — для действий (запись в БД, отправка email, вызов внутренних API). Создадим агента-исследователя:

def save_to_file(content: str, filename: str) -> str:
    """Сохраняет текст в файл."""
    with open(filename, "w", encoding="utf-8") as f:
        f.write(content)
    return f"Файл '{filename}' сохранён ({len(content)} символов)"

# Комбинированная конфигурация: Google Search + кастомные функции
hybrid_tools = [
    Tool(google_search=GoogleSearch()),
    Tool(function_declarations=[{
        "name": "save_to_file",
        "description": "Сохраняет текстовый контент в файл на диске.",
        "parameters": {
            "type": "object",
            "properties": {
                "content": {"type": "string"},
                "filename": {"type": "string"}
            },
            "required": ["content", "filename"]
        }
    }]),
]

# Запуск агента-исследователя
response = client.models.generate_content(
    model="gemini-2.5-pro-exp-03-25",
    contents="""
    Исследуй последние новости об AI-агентах за июнь 2026.
    Найди 3 ключевые новости, суммируй их и сохрани результат
    в файл ai_agent_news_june_2026.txt
    """,
    config=GenerateContentConfig(
        tools=hybrid_tools,
    ),
)

print(response.text)

💡 Pro-совет: При использовании Google Search grounding ответ модели может содержать маркеры цитирования вида [1], [2]. Gemini автоматически вставляет их в текст, связывая утверждения с конкретными источниками. Это делает ответы агента проверяемыми и снижает риск галлюцинаций до минимума.

Google Search Grounding радикально меняет возможности агентов: вместо статичной базы знаний или ручной интеграции поисковых API вы получаете доступ ко всему индексу Google «из коробки», с автоматическим цитированием и без дополнительного кода.

4. Code Execution — агент, который пишет и запускает код

Code Execution — ещё одна уникальная возможность Gemini. Модель не просто генерирует код как текст — она может выполнить его в изолированной песочнице и вернуть результат. Это открывает совершенно новый класс агентов: анализ данных, построение графиков, математическое моделирование, генерация отчётов — всё это происходит внутри одного вызова API.

🔒 Безопасность: Код выполняется в полностью изолированной Google-песочнице. У кода нет доступа к интернету, файловой системе пользователя или переменным окружения. Доступны только стандартные Python-библиотеки: math, numpy, pandas, matplotlib, scipy, sympy, statistics.

Активация Code Execution

from google.genai.types import CodeExecution, Tool

# Инструмент для исполнения кода
code_tool = Tool(code_execution=CodeExecution())

response = client.models.generate_content(
    model="gemini-2.5-pro-exp-03-25",
    contents="""
    Сгенерируй массив из 1000 случайных чисел,
    построй гистограмму распределения и вычисли:
    среднее, медиану, стандартное отклонение, 95-й перцентиль.
    Сохрани график как PNG.
    """,
    config=GenerateContentConfig(
        tools=[code_tool],
    ),
)

# Обработка ответа с кодом и результатами
for part in response.candidates[0].content.parts:
    if part.executable_code:
        print("📝 Сгенерированный код:")
        print(part.executable_code.code)
    elif part.code_execution_result:
        print("📊 Результат выполнения:")
        print(part.code_execution_result.output)
    elif part.inline_data:
        # Сгенерированное изображение (график)
        import base64
        img_data = base64.b64decode(part.inline_data.data)
        with open("histogram.png", "wb") as f:
            f.write(img_data)
        print("🖼 График сохранён как histogram.png")

Агент-аналитик данных с Code Execution

Создадим агента, который принимает на вход CSV-данные, анализирует их с помощью pandas в песочнице Gemini и возвращает структурированный аналитический отчёт с графиками:

# Агент-аналитик: данные → pandas → анализ → отчёт + графики
csv_data = """
date,product,quantity,price,region
2026-06-01,Widget A,120,19.99,EU
2026-06-01,Widget B,85,29.99,US
2026-06-02,Widget A,95,19.99,EU
2026-06-02,Widget B,110,29.99,US
2026-06-03,Widget A,140,19.99,Asia
2026-06-03,Widget B,75,29.99,EU
2026-06-04,Widget A,160,19.99,US
2026-06-04,Widget B,90,29.99,Asia
2026-06-05,Widget A,130,19.99,EU
2026-06-05,Widget B,100,29.99,US
"""

response = client.models.generate_content(
    model="gemini-2.5-pro-exp-03-25",
    contents=[
        "Вот CSV с данными о продажах:",
        csv_data,
        """
        Проанализируй данные с помощью pandas:
        1. Посчитай общую выручку по каждому продукту
        2. Построй график продаж по дням
        3. Найди самый прибыльный регион
        4. Сделай прогноз на следующий день линейной регрессией
        """,
    ],
    config=GenerateContentConfig(
        tools=[code_tool],
    ),
)

for part in response.candidates[0].content.parts:
    if part.text:
        print(part.text)
    elif part.executable_code:
        print("[Код]\n", part.executable_code.code[:500])
    elif part.code_execution_result:
        print("[Результат]\n", part.code_execution_result.output[:500])

💡 Когда использовать Code Execution vs Function Calling: Code Execution идеален для вычислений и анализа данных, где модель сама решает, какой код написать. Function calling — для интеграции с внешними системами (API, базы данных, файловая система). В продвинутых агентах эти два механизма комбинируются: агент вызывает ваши функции для действий и использует code execution для расчётов.

Code Execution превращает Gemini из «говорящей» модели в «действующую» — агент может не только рассуждать о данных, но и самостоятельно производить вычисления, строить визуализации и проверять гипотезы программно.

5. Мультимодальный агент: анализ изображений + текст

Gemini 2.5 Pro — нативно мультимодальная модель. Это означает, что она принимает на вход не только текст, но и изображения, аудио, видео и PDF-файлы. Для агента это открывает сценарии, недоступные текстовым моделям: анализ скриншотов, чтение документов, распознавание объектов на фото, работа с диаграммами и графиками.

Загрузка и анализ изображения

from google.genai.types import Part

def load_image_as_part(path: str) -> Part:
    """Загружает изображение и возвращает Part для Gemini."""
    with open(path, "rb") as img_file:
        image_data = img_file.read()

    # Определяем MIME-тип по расширению
    ext = path.lower().split(".")[-1]
    mime_types = {
        "png": "image/png",
        "jpg": "image/jpeg",
        "jpeg": "image/jpeg",
        "gif": "image/gif",
        "webp": "image/webp",
    }

    return Part.from_bytes(
        data=image_data,
        mime_type=mime_types.get(ext, "image/png"),
    )

# Анализ изображения с параллельным function calling
image_part = load_image_as_part("dashboard_screenshot.png")

response = client.models.generate_content(
    model="gemini-2.5-pro-exp-03-25",
    contents=[
        image_part,
        """
        Опиши, что изображено на этом скриншоте дашборда.
        Определи ключевые метрики, найди аномалии и предложи
        действия для улучшения показателей.
        """,
    ],
    config=GenerateContentConfig(
        system_instruction=(
            "Ты — эксперт по аналитике данных. Отвечай структурированно, "
            "выделяя ключевые наблюдения и рекомендации."
        ),
    ),
)

print(response.text)

Мультимодальный агент с извлечением текста (OCR) и поиском

Объединим всё вместе: агент принимает изображение документа, извлекает текст (нативный OCR Gemini), анализирует содержимое и при необходимости ищет дополнительную информацию через Google Search:

# Мультимодальный агент: изображение → OCR → анализ → поиск → отчёт

document_image = load_image_as_part("invoice_scan.jpg")

response = client.models.generate_content(
    model="gemini-2.5-pro-exp-03-25",
    contents=[
        document_image,
        """
        Это скан счёта-фактуры (инвойса).
        1. Извлеки все реквизиты: номер, дату, сумму, контрагентов.
        2. Проверь актуальность НДС-ставки для указанной категории товаров
           (используй Google Search, если нужно).
        3. Сформируй структурированную JSON-выписку.
        4. Если найдешь несоответствия — отметь их.
        """,
    ],
    config=GenerateContentConfig(
        tools=[Tool(google_search=GoogleSearch())],
        system_instruction="Ты — агент-бухгалтер. Работаешь с первичной документацией. Всегда проверяй актуальные ставки налогов.",
    ),
)

print(response.text)

# Вывод источников поиска
if response.candidates[0].grounding_metadata:
    for chunk in response.candidates[0].grounding_metadata.grounding_chunks:
        if chunk.web:
            print(f"📎 {chunk.web.title}: {chunk.web.uri}")

Поддерживаемые модальности

Тип данных	Поддержка	Ограничения
Изображения (PNG, JPEG, WebP, GIF)	✅ Полная	До 20 MB на изображение
PDF-документы	✅ Полная	До 3 600 страниц; каждая страница = 258 токенов
Аудио (MP3, WAV, FLAC)	✅ Полная	До 9.5 часов; автоматическая транскрипция
Видео (MP4, MOV)	✅ С ключевыми кадрами	1 кадр в секунду; без аудиодорожки
Текстовые файлы (TXT, CSV, JSON)	✅ Полная	Встраиваются в контекст

Мультимодальность — это не просто «фича», а фундаментальное архитектурное преимущество Gemini. Агент может работать с любыми данными без промежуточных конвертеров и отдельных OCR-сервисов, что упрощает пайплайн и уменьшает количество точек отказа.

6. Интеграция с LangChain: Gemini как LLM в LangChain-агенте

LangChain — самый популярный фреймворк для построения LLM-приложений на Python. Благодаря пакету langchain-google-genai вы можете использовать Gemini 2.5 Pro как «мозг» для LangChain-агентов, получая доступ к богатой экосистеме инструментов: векторные хранилища (Chroma, Pinecone), загрузчики документов, memory-менеджеры и готовые цепочки обработки.

Установка и базовая интеграция

pip install langchain langchain-google-genai langchain-community

from langchain_google_genai import ChatGoogleGenerativeAI
from langchain.agents import create_agent
from langchain.tools import tool
import os

# Инициализация Gemini через LangChain
llm = ChatGoogleGenerativeAI(
    model="gemini-2.5-pro-exp-03-25",
    google_api_key=os.getenv("GEMINI_API_KEY"),
    temperature=0.3,
    max_output_tokens=4096,
)

# Определяем инструменты LangChain
@tool
def multiply(a: float, b: float) -> float:
    """Умножает два числа."""
    return a * b

@tool
def get_weather(city: str) -> str:
    """Возвращает погоду в городе (заглушка)."""
    weather_data = {
        "москва": "+22°C, солнечно",
        "лондон": "+15°C, облачно",
        "токио": "+28°C, дождь",
        "нью-йорк": "+18°C, переменная облачность",
    }
    return weather_data.get(city.lower(), f"Нет данных для города {city}")

# Создаём LangChain-агента
tools = [multiply, get_weather]
agent = create_agent(llm, tools)

# Запускаем агента
result = agent.invoke({
    "input": "Какая сейчас погода в Токио? И посчитай 15 умножить на 27."
})

print(result["output"])

Gemini + LangChain + Google Search + Векторная память

Продвинутый сценарий: агент с долговременной памятью на базе векторного хранилища Chroma, Google Search для актуальной информации и Gemini как ядром рассуждений:

from langchain.vectorstores import Chroma
from langchain_google_genai import GoogleGenerativeAIEmbeddings
from langchain.tools.retriever import create_retriever_tool
from langchain_community.tools import GoogleSearchRun
from langchain.memory import ConversationSummaryBufferMemory

# 1. Векторное хранилище для долговременной памяти
embeddings = GoogleGenerativeAIEmbeddings(
    model="models/text-embedding-004",
    google_api_key=os.getenv("GEMINI_API_KEY"),
)
vectorstore = Chroma(
    persist_directory="./agent_memory",
    embedding_function=embeddings,
)

# Инструмент поиска по памяти агента
retriever_tool = create_retriever_tool(
    vectorstore.as_retriever(search_kwargs={"k": 5}),
    name="memory_search",
    description="Поиск по истории взаимодействий агента. Используй, когда нужен контекст прошлых диалогов.",
)

# 2. Google Search через LangChain (требуется SerpAPI-ключ)
# Альтернатива — использовать нативный grounding Gemini (см. секцию 3)

# 3. Сборка агента со всеми инструментами
all_tools = [multiply, get_weather, retriever_tool]

# Память диалога с суммаризацией
memory = ConversationSummaryBufferMemory(
    llm=llm,
    max_token_limit=500,
    memory_key="chat_history",
    return_messages=True,
)

# Создаём и запускаем агента
agent_with_memory = create_agent(llm, all_tools)

# Первый запрос
result = agent_with_memory.invoke({
    "input": "Меня зовут Алексей. Запомни, что я работаю с Python и интересуюсь AI-агентами."
})
print(result["output"])

# Второй запрос — агент использует память
result = agent_with_memory.invoke({
    "input": "Как меня зовут и чем я интересуюсь? Предложи 3 полезных инструмента для моей работы."
})
print(result["output"])

Сравнение: нативный google-genai SDK vs LangChain

Критерий	google-genai SDK	LangChain + Gemini
Скорость	⚡ Максимальная (прямой API)	🟡 Небольшой оверхед
Function calling	✅ Нативный, параллельный	✅ Через LangChain tools
Google Search grounding	✅ Нативный	❌ Только через SerpAPI
Code Execution	✅ Нативный	❌ Не поддерживается
Векторные хранилища	❌ Ручная интеграция	✅ Из коробки (Chroma, Pinecone...)
Memory / история диалога	🟡 Ручное управление	✅ Готовые классы памяти
Загрузка документов	🟡 Только через Part	✅ 100+ загрузчиков
Сложность освоения	🟢 Низкая	🟡 Средняя

💡 Рекомендация: Для агентов, которым критичны Google Search grounding и Code Execution — используйте нативный google-genai SDK. Для проектов, где нужна экосистема LangChain (векторные БД, загрузчики, сложные цепочки) — используйте LangChain с Gemini как LLM, но имейте в виду, что часть нативных фич Gemini будет недоступна.

LangChain и google-genai SDK не исключают друг друга. Оптимальная архитектура: используйте google-genai SDK для прямых вызовов Gemini с нативными фичами, а LangChain — для оркестрации высокоуровневых пайплайнов и интеграции с внешними системами.

♊ Итоги: что мы построили

За 20 минут мы прошли путь от нуля до полноценного AI-агента на Gemini 2.5 Pro, освоив все ключевые компоненты:

Установка и настройка — google-genai SDK, API-ключ, первое подключение к Gemini 2.5 Pro.
Function Calling — цикл агента с автоматическим вызовом Python-функций и параллельным исполнением.
Google Search Grounding — поиск в реальном времени с автоматическим цитированием источников.
Code Execution — генерация и исполнение кода в изолированной песочнице для анализа данных и визуализации.
Мультимодальность — работа с изображениями, PDF, аудио и видео без внешних OCR/транскрибаторов.
Интеграция с LangChain — использование Gemini в экосистеме LangChain с векторной памятью и инструментами.

Gemini 2.5 Pro — это не просто ещё одна LLM. Это полноценная агентная платформа, где миллионный контекст, нативный function calling, Google Search и code execution работают в единой связке. Для Python-разработчика это означает, что production-grade агента можно построить за часы, а не недели — без микросервисов для поиска, без отдельных песочниц для кода, без OCR-сервисов.

Следующий шаг — возьмите код из этого гайда, адаптируйте под свою предметную область и запустите первого агента. От прототипа в Google AI Studio до продакшена на Vertex AI — весь путь лежит через один и тот же SDK.

🚀 Дальнейшее развитие: Попробуйте комбинировать все инструменты в одном агенте — Google Search + function calling + code execution. Добавьте стриминг ответов через client.models.generate_content_stream(). Подключите Vertex AI Agent Builder для managed-деплоя. Изучите мультиагентные паттерны, где несколько экземпляров Gemini координируются для решения сложных задач.