### Zero-Shot CoT Example (Russian)

Source: https://github.com/pridees/agentic-design-patterns-book-rus/blob/main/Приложения/Приложение A. Продвинутые техники промптинга.md

Demonstrates the Zero-Shot Chain of Thought prompting technique by adding a phrase to encourage step-by-step reasoning. This example is in Russian.

```text
Если поезд движется со скоростью 60 миль в час и покрывает расстояние 240 миль, сколько времени заняла поездка? Давайте думать пошагово.
```

--------------------------------

### Few-Shot CoT Example 2 (Russian)

Source: https://github.com/pridees/agentic-design-patterns-book-rus/blob/main/Приложения/Приложение A. Продвинутые техники промптинга.md

Provides a second example of Few-Shot CoT in Russian, involving a word problem about apples, demonstrating step-by-step calculation.

```text
В: У Сары есть 5 яблок, и она покупает еще 8. Она съедает 3 яблока. Сколько яблок у неё осталось? Давайте думать пошагово.
О: Давайте думать пошагово. Сара начинает с 5 яблок. Она покупает еще 8, поэтому добавляет 8 к своему первоначальному количеству: 5 + 8 = 13 яблок. Затем она съедает 3 яблока, поэтому вычитаем 3 из общего количества: 13 - 3 = 10. У Сары осталось 10 яблок. Ответ: 10.
```

--------------------------------

### Few-Shot CoT Example 1 (Russian)

Source: https://github.com/pridees/agentic-design-patterns-book-rus/blob/main/Приложения/Приложение A. Продвинутые техники промптинга.md

Illustrates Few-Shot Chain of Thought prompting with a math problem. It shows an input, step-by-step reasoning, and the final answer in Russian.

```text
В: Сумма трех последовательных целых чисел равна 36. Какие это числа?
О: Пусть первое целое число будет x. Следующее последовательное целое число — x+1, а третье — x+2. Сумма равна x + (x+1) + (x+2) = 3x + 3. Мы знаем, что сумма равна 36, поэтому 3x + 3 = 36. Вычитаем 3 с обеих сторон: 3x = 33. Делим на 3: x = 11. Числа: 11, 11+1=12 и 11+2=13. Числа: 11, 12 и 13.
```

--------------------------------

### Инициализация LangChain с OpenAI GPT-4o

Source: https://github.com/pridees/agentic-design-patterns-book-rus/blob/main/Часть 1/Глава 4. Рефлексия.md

Пример кода Python, демонстрирующий настройку и инициализацию чат-модели OpenAI GPT-4o с использованием LangChain. Включает загрузку переменных окружения для API-ключа и проверку его наличия.

```python
import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.messages import SystemMessage, HumanMessage

# --- Configuration ---
# Load environment variables from .env file (for OPENAI_API_KEY)
load_dotenv()

# Check if the API key is set
if not os.getenv("OPENAI_API_KEY"):
    raise ValueError("OPENAI_API_KEY not found in .env file. Please add it.")

# Initialize the Chat LLM. We use gpt-4o for better reasoning.
```

--------------------------------

### Dynamic LLM Routing Example

Source: https://github.com/pridees/agentic-design-patterns-book-rus/blob/main/Часть 4/Глава 16. Оптимизация с учетом ресурсов.md

Illustrates dynamic routing based on request complexity and budget constraints. Simple requests are routed to faster, cheaper models, while complex ones go to more powerful, albeit costlier, models.

```Conceptual
IF request_complexity == 'simple' AND budget_allowance == 'low' THEN route_to(Gemini_Flash)
ELSE IF request_complexity == 'complex' AND budget_allowance == 'high' THEN route_to(Gemini_Pro)
ELSE route_to(Gemini_Pro) // Default or fallback
```

--------------------------------

### SWEngineer Agent Prompt for Directing ML Engineers

Source: https://github.com/pridees/agentic-design-patterns-book-rus/blob/main/Часть 4/Глава 21. Исследование и открытие.md

Outlines the role of a Software Engineering Agent in guiding ML Engineering Agents to create straightforward data preparation code. It stresses the importance of aligning the code with research objectives by incorporating literature reviews and experimental plans.

```English
"You are a software engineer directing a machine learning engineer, where the machine learning engineer will be writing the code, and you can interact with them through dialogue.\n""Your goal is to help the ML engineer produce code that prepares the data for the provided experiment. You should aim for very simple code to prepare the data, not complex code. You should integrate the provided literature review and the plan and come up with code to prepare data for this experiment.\n"
```

--------------------------------

### ChatGPT Agent: Автономная навигация и выполнение кода

Source: https://github.com/pridees/agentic-design-patterns-book-rus/blob/main/Приложения/Приложение B. Агентные взаимодействия ИИ от GUI до реального мира.md

ChatGPT Agent обладает способностью автономно перемещаться по интернету для получения данных в реальном времени, генерировать и выполнять вычислительный код для анализа данных, а также взаимодействовать со сторонними приложениями. Это позволяет ему выполнять сложные рабочие процессы и задачи, такие как рыночный анализ или планирование логистики.

```Python
class ChatGPTAgent:
    def __init__(self):
        # Инициализация агента, настройка API и инструментов
        pass

    def navigate_internet(self, query):
        # Логика для поиска информации в интернете
        print(f"Навигация по интернету для: {query}")
        return "Результаты поиска..."

    def execute_code(self, code_snippet):
        # Логика для выполнения предоставленного кода
        print(f"Выполнение кода: {code_snippet}")
        try:
            exec(code_snippet)
            return "Код успешно выполнен."
        except Exception as e:
            return f"Ошибка при выполнении кода: {e}"

    def interact_with_app(self, app_name, action):
        # Логика для взаимодействия со сторонними приложениями
        print(f"Взаимодействие с приложением {app_name} для выполнения действия: {action}")
        return f"Действие {action} в {app_name} выполнено."

    def process_directive(self, directive):
        # Обработка пользовательской директивы, оркестрация действий
        print(f"Обработка директивы: {directive}")
        if "рыночный анализ" in directive:
            search_results = self.navigate_internet("рыночные данные")
            # Пример выполнения кода для анализа
            analysis_code = "import pandas as pd\ndf = pd.DataFrame({'data': [1, 2, 3]}); print(df.describe())"
            self.execute_code(analysis_code)
        elif "планирование логистики" in directive:
            self.interact_with_app("Календарь", "создать событие")
        return "Директива обработана."
```

--------------------------------

### Определение агента FastMCP Greeter

Source: https://github.com/pridees/agentic-design-patterns-book-rus/blob/main/Часть 2/Глава 10. Протокол контекста модели.md

Этот код определяет агента LLM с именем 'fastmcp_greeter_agent', который использует модель Gemini. Агент инструктирован действовать как дружелюбный ассистент и оснащен инструментом 'greet' через MCP Toolset, подключенный к локальному FastMCP-серверу.

```Python
FASTMCP_SERVER_URL = "http://localhost:8000"

root_agent = LlmAgent(
    model='gemini-2.0-flash',  # Или ваша предпочитаемая модель
    name='fastmcp_greeter_agent',
    instruction='Вы дружелюбный ассистент, который может приветствовать людей по имени. Используйте инструмент "greet".',
    tools=[
        MCPToolset(
            connection_params=HttpServerParameters(
                url=FASTMCP_SERVER_URL,
            ),
            # Опционально: Отфильтровать, какие инструменты от MCP-сервера предоставляются
            # Для этого примера мы ожидаем только 'greet'
            tool_filter=['greet']
        )
    ],
)

```

--------------------------------

### Пример маршрутизации на базе LLM

Source: https://github.com/pridees/agentic-design-patterns-book-rus/blob/main/Часть 1/Глава 2. Маршрутизация.md

Использование языковой модели для классификации запроса пользователя и определения следующего действия.

```LLM Prompt
Проанализируй запрос пользователя и выдай только категорию: ‘Order Status’, ‘Product Info’, ‘Technical Support’ или ‘Other’.
```

--------------------------------

### Интеграция VertexAiMemoryBankService с Google ADK

Source: https://github.com/pridees/agentic-design-patterns-book-rus/blob/main/Часть 2/Глава 8. Управление памятью.md

Пример кода на Python для инициализации VertexAiMemoryBankService и добавления сессии агента в память. Требует указания PROJECT_ID и LOCATION.

```Python
from google.adk.memory import VertexAiMemoryBankService

agent_engine_id = agent_engine.api_resource.name.split("/")[-1]

memory_service = VertexAiMemoryBankService(
    project="PROJECT_ID",
    location="LOCATION",
    agent_engine_id=agent_engine_id
)

session = await session_service.get_session(
    app_name=app_name,
    user_id="USER_ID",
    session_id=session.id
)
await memory_service.add_session_to_memory(session)
```

--------------------------------

### Использование VertexAiSessionService в Python

Source: https://github.com/pridees/agentic-design-patterns-book-rus/blob/main/Часть 2/Глава 8. Управление памятью.md

Пример использования VertexAiSessionService для масштабируемого продакшна на Google Cloud Platform. Требует установки google-adk[vertexai] и настройки/аутентификации GCP. Этот сервис использует инфраструктуру Vertex AI для управления сессиями.

```Python
from google.adk.sessions import VertexAiSessionService

PROJECT_ID = "your-gcp-project-id"  # Замените на ваш ID проекта GCP
LOCATION = "us-central1"  # Замените на желаемое расположение GCP
# app_name, используемый с этим сервисом, должен соответствовать ID или имени Reasoning Engine
REASONING_ENGINE_APP_NAME = "projects/your-gcp-project-id/locations/us-central1/reasoningEngines/your-engine-id"  # Замените на имя ресурса вашего Reasoning Engine

session_service = VertexAiSessionService(project=PROJECT_ID, location=LOCATION)
# При использовании этого сервиса передавайте REASONING_ENGINE_APP_NAME в методы сервиса:
# session_service.create_session(app_name=REASONING_ENGINE_APP_NAME, ...)
# session_service.get_session(app_name=REASONING_ENGINE_APP_NAME, ...)
# session_service.append_event(session, event, app_name=REASONING_ENGINE_APP_NAME)
# session_service.delete_session(app_name=REASONING_ENGINE_APP_NAME, ...)
```

--------------------------------

### Пример разговорного промпта для Vibe Coding

Source: https://github.com/pridees/agentic-design-patterns-book-rus/blob/main/Приложения/Приложение B. Агентные взаимодействия ИИ от GUI до реального мира.md

Примеры того, как разработчик может взаимодействовать с ИИ-помощником, используя естественный язык для постановки задач и уточнения результатов.

```Natural Language
Создай простую, современно выглядящую лендинговую страницу для нового приложения.
```

```Natural Language
Рефактори эту функцию, чтобы она была более Pythonic и читаемой.
```

```Natural Language
Это хорошее начало, но можешь сделать кнопки синими?
```

```Natural Language
Добавь обработку ошибок к этому.
```

--------------------------------

### Реализация рефлексии с помощью LangChain

Source: https://github.com/pridees/agentic-design-patterns-book-rus/blob/main/Часть 1/Глава 4. Рефлексия.md

Пример использования паттерна «Рефлексия» в LangChain, где специальный 'reflector_prompt' создает персону критика для оценки и улучшения вывода агента-продюсера.

```python
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_openai import ChatOpenAI

# Пример промпта для критика
reflector_prompt = ChatPromptTemplate.from_messages([
    ("system", "Вы — опытный редактор, оценивающий качество кода. Ищите ошибки, неэффективность и предлагайте улучшения."),
    ("human", "Оцените следующий код: {code}")
])

# Пример промпта для продюсера
producer_prompt = ChatPromptTemplate.from_messages([
    ("system", "Вы — программист, пишущий код на Python."),
    ("human", "Напишите функцию для вычисления факториала.")
])

llm = ChatOpenAI(model="gpt-4o")

# Цепочка для продюсера
producer_chain = producer_prompt | llm

# Цепочка для критика
critic_chain = reflector_prompt | llm

# Функция для выполнения рефлексии
def reflect_on_code(code_output):
    evaluation = critic_chain.invoke({"code": code_output})
    # Здесь может быть логика для обработки оценки и повторной генерации
    print(f"Оценка критика: {evaluation.content}")
    return evaluation.content

# Пример использования:
initial_code = producer_chain.invoke({})
print(f"Первоначальный код: {initial_code.content}")

# Рефлексия над кодом
reflection_result = reflect_on_code(initial_code.content)

# В реальном приложении здесь может быть цикл для итеративного улучшения

```

--------------------------------

### Установка библиотек LangChain

Source: https://github.com/pridees/agentic-design-patterns-book-rus/blob/main/Часть 1/Глава 1. Цепочки промптов.md

Команда для установки необходимых библиотек Python для работы с LangChain, включая поддержку OpenAI и LangGraph.

```bash
pip install langchain langchain-community langchain-openai langgraph
```

--------------------------------

### Определение SequentialAgent для параллельного исследования и синтеза

Source: https://github.com/pridees/agentic-design-patterns-book-rus/blob/main/Часть 1/Глава 3. Параллелизация.md

Этот код определяет SequentialAgent, который сначала запускает параллельное исследование с помощью ParallelAgent, а затем использует MergerAgent для синтеза результатов. Он координирует общий поток выполнения.

```Python
sequential_pipeline_agent = SequentialAgent(
    name="ResearchAndSynthesisPipeline",
    # Run parallel research first, then merge
    sub_agents=[parallel_research_agent, merger_agent],
    description="Coordinates parallel research and synthesizes the results."
)

root_agent = sequential_pipeline_agent
```

--------------------------------

### Создание агента Google Search

Source: https://github.com/pridees/agentic-design-patterns-book-rus/blob/main/Часть 4/Глава 17. Техники рассуждения.md

Этот код демонстрирует создание агента Google Search с использованием модели 'gemini-2.0-flash' и инструкции на русском языке, указывающей на специализацию в Google Search.

```Python
from langgraph.graph import StateGraph, END
from typing import TypedDict, Annotated
import operator
from langchain_core.tools import tool

from langgraph.checkpoint.memory import MemorySaver

from langchain_google_genai import ChatGoogleGenerativeAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough

from langchain_community.tools.google_search import GoogleSearch


@tool
def google_search(query: str) -> str:
    """Google Search tool"""
    search = GoogleSearch()
    return search.run(query)


class Agent(TypedDict):
    model: str
    name: str
    instruction: str
    tools: list


search_agent = Agent(
    model='gemini-2.0-flash',
    name='SearchAgent',
    instruction="""
    Вы - специалист по Google Search
    """,
    tools=[google_search],
)

class Agent(TypedDict):
    model: str
    name: str
    instruction: str
    code_executor: list


coding_agent = Agent(
    model='gemini-2.0-flash',
    name='CodeAgent',
    instruction="""
    Вы - специалист по выполнению кода
    """,
    code_executor=[BuiltInCodeExecutor],
)

class Agent(TypedDict):
    name: str
    model: str
    description: str
    tools: list


root_agent = Agent(
    name="RootAgent",
    model="gemini-2.0-flash",
    description="Корневой агент",
    tools=[agent_tool.AgentTool(agent=search_agent), agent_tool.AgentTool(agent=coding_agent)],
)

```

--------------------------------

### ML Engineering Agent Prompt for Data Preparation

Source: https://github.com/pridees/agentic-design-patterns-book-rus/blob/main/Часть 4/Глава 21. Исследование и открытие.md

Provides instructions for an ML Engineering Agent to generate simple data preparation code. It emphasizes collaboration with a PhD student and integration of literature review and experimental plans.

```English
"You are a machine learning engineer being directed by a PhD student who will help you write the code, and you can interact with them through dialogue.\n""Your goal is to produce code that prepares the data for the provided experiment. You should aim for simple code to prepare the data, not complex code. You should integrate the provided literature review and the plan and come up with code to prepare data for this experiment.\n"
```

--------------------------------

### Python: Инициализация и запуск OpenEvolve для оптимизации кода

Source: https://github.com/pridees/agentic-design-patterns-book-rus/blob/main/Часть 2/Глава 9. Обучение и адаптация.md

Этот фрагмент кода демонстрирует использование библиотеки OpenEvolve для инициализации процесса эволюционной оптимизации программы. Он настраивает пути к начальной программе, файлу оценки и конфигурации, а затем запускает эволюцию на 1000 итераций, выводя метрики лучшей найденной программы.

```Python
from openevolve import OpenEvolve

# Initialize the system
evolve = OpenEvolve(
    initial_program_path="path/to/initial_program.py",
    evaluation_file="path/to/evaluator.py",
    config_path="path/to/config.yaml"
)

# Run the evolution
best_program = await evolve.run(iterations=1000)
print(f"Best program metrics:")
for name, value in best_program.metrics.items():
    print(f"  {name}: {value:.4f}")
```

--------------------------------

### Параллельное выполнение задач с LangChain

Source: https://github.com/pridees/agentic-design-patterns-book-rus/blob/main/Часть 1/Глава 3. Параллелизация.md

Пример реализации параллельного рабочего процесса с использованием LangChain Expression Language (LCEL). Демонстрирует запуск нескольких независимых цепочек (summarize_chain, questions_chain, terms_chain) параллельно и агрегацию их результатов.

```Python
import os
import asyncio
from typing import Optional
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import Runnable, RunnableParallel, RunnablePassthrough

# --- Configuration ---
# Ensure your API key environment variable is set (e.g., OPENAI_API_KEY)
try:
    llm: Optional[ChatOpenAI] = ChatOpenAI(model="gpt-4o-mini", temperature=0.7)
except Exception as e:
    print(f"Error initializing language model: {e}")
    llm = None

# --- Define Independent Chains ---
# These three chains represent distinct tasks that can be executed in parallel.
summarize_chain: Runnable = (
    ChatPromptTemplate.from_messages([
        ("system", "Summarize the following topic concisely:"),
        ("user", "{topic}")
    ])
    | llm
    | StrOutputParser()
)

questions_chain: Runnable = (
    ChatPromptTemplate.from_messages([
        ("system", "Generate three interesting questions about the following topic:"),
        ("user", "{topic}")
    ])
    | llm
    | StrOutputParser()
)

terms_chain: Runnable = (
    ChatPromptTemplate.from_messages([
        ("system", "Identify 5-10 key terms from the following topic, separated by commas:"),
        ("user", "{topic}")
    ])
    | llm
    | StrOutputParser()
)

# --- Build the Parallel + Synthesis Chain ---
```

--------------------------------

### Пример использования банка памяти в Vibe Coding

Source: https://github.com/pridees/agentic-design-patterns-book-rus/blob/main/Приложения/Приложение B. Агентные взаимодействия ИИ от GUI до реального мира.md

Демонстрация того, как разработчик может сохранять предпочтения или ограничения в 'банке памяти' ИИ для обеспечения последовательности генерации кода.

```Natural Language
Сохрани специфический стиль кодирования или набор требований проекта в память ИИ.
```

--------------------------------

### Установка зависимостей LangChain

Source: https://github.com/pridees/agentic-design-patterns-book-rus/blob/main/Часть 1/Глава 4. Рефлексия.md

Команда для установки необходимых библиотек Python для работы с LangChain, LangChain Community и LangChain OpenAI.

```bash
pip install langchain langchain-community langchain-openai
```

--------------------------------

### Установка зависимостей для LangChain и Google Generative AI

Source: https://github.com/pridees/agentic-design-patterns-book-rus/blob/main/Часть 1/Глава 2. Маршрутизация.md

Команда для установки необходимых Python библиотек, включая LangChain, LangGraph и Google Generative AI, для реализации паттерна маршрутизации.

```bash
pip install langchain langgraph google-cloud-aiplatform langchain-google-genai google-adk deprecated pydantic
```

--------------------------------

### Факторизованное познание / Декомпозиция задач

Source: https://github.com/pridees/agentic-design-patterns-book-rus/blob/main/Приложения/Приложение A. Продвинутые техники промптинга.md

Разбиение сложных задач на более мелкие подзадачи и промптинг модели для каждой из них. Результаты затем объединяются.

```Russian
Для написания исследовательской работы:
  - Промпт 1: "Сгенерируй подробный план для статьи о влиянии ИИ на рынок труда."
  - Промпт 2: "Напиши раздел введения на основе этого плана: [вставить план введения]."
  - Промпт 3: "Напиши раздел 'Влияние на работников умственного труда' на основе этого плана: [вставить раздел плана]." (Повторить для других разделов).
  - Промпт N: "Объедини эти разделы и напиши заключение."
```

--------------------------------

### Классификация и обработка запросов с OpenAI

Source: https://github.com/pridees/agentic-design-patterns-book-rus/blob/main/Часть 4/Глава 16. Оптимизация с учетом ресурсов.md

Пример кода на Python, который классифицирует пользовательские запросы с помощью OpenAI API на 'simple', 'reasoning' или 'internet_search'. Он также включает функцию для выполнения поиска в Google и генерации ответов на основе классификации и результатов поиска.

```Python
# MIT License
# Copyright (c) 2025 Mahtab Syed
# https://www.linkedin.com/in/mahtabsyed/

import os
import requests
import json
from dotenv import load_dotenv
from openai import OpenAI

# Загрузка переменных окружения
load_dotenv()
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
GOOGLE_CUSTOM_SEARCH_API_KEY = os.getenv("GOOGLE_CUSTOM_SEARCH_API_KEY")
GOOGLE_CSE_ID = os.getenv("GOOGLE_CSE_ID")

if not OPENAI_API_KEY or not GOOGLE_CUSTOM_SEARCH_API_KEY or not GOOGLE_CSE_ID:
    raise ValueError(
        "Пожалуйста, установите OPENAI_API_KEY, GOOGLE_CUSTOM_SEARCH_API_KEY и GOOGLE_CSE_ID в вашем .env файле."
    )

client = OpenAI(api_key=OPENAI_API_KEY)

# --- Шаг 1: Классификация промпта ---
def classify_prompt(prompt: str) -> dict:
    system_message = {
        "role": "system",
        "content": (
            "Вы классификатор, который анализирует пользовательские промпты и возвращает ТОЛЬКО одну из трех категорий:\n\n"
            "- simple\n"
            "- reasoning\n"
            "- internet_search\n\n"
            "Правила:\n"
            "- Используйте 'simple' для прямых фактических вопросов, не требующих рассуждений или текущих событий."
            "- Используйте 'reasoning' для логических, математических вопросов или вопросов многоэтапного вывода."
            "- Используйте 'internet_search', если промпт ссылается на текущие события, недавние данные или вещи, отсутствующие в ваших обучающих данных.\n\n"
            "Отвечайте ТОЛЬКО JSON как:\n"
            '{ "classification": "simple" }'
        ),
    }

    user_message = {"role": "user", "content": prompt}

    response = client.chat.completions.create(
        model="gpt-4o", messages=[system_message, user_message], temperature=1
    )

    reply = response.choices[0].message.content
    return json.loads(reply)

# --- Шаг 2: Поиск Google ---
def google_search(query: str, num_results=1) -> list:
    url = "https://www.googleapis.com/customsearch/v1"
    params = {
        "key": GOOGLE_CUSTOM_SEARCH_API_KEY,
        "cx": GOOGLE_CSE_ID,
        "q": query,
        "num": num_results,
    }

    try:
        response = requests.get(url, params=params)
        response.raise_for_status()
        results = response.json()

        if "items" in results and results["items"]:
            return [
                {
                    "title": item.get("title"),
                    "snippet": item.get("snippet"),
                    "link": item.get("link"),
                }
                for item in results["items"]
            ]
        else:
            return []
    except requests.exceptions.RequestException as e:
        return {"error": str(e)}

# --- Шаг 3: Генерация ответа ---
def generate_response(prompt: str, classification: str, search_results=None) -> str:
    if classification == "simple":
        model = "gpt-4o-mini"
        full_prompt = prompt
    elif classification == "reasoning":
        model = "o4-mini"
        full_prompt = prompt
    elif classification == "internet_search":
        model = "gpt-4o"
        # Преобразование каждого результата поиска в читаемую строку
        if search_results:
            search_context = "\n".join(
                [
                    f"Заголовок: {item.get('title')}\nФрагмент: {item.get('snippet')}\nСсылка: {item.get('link')}"
                    for item in search_results
                ]
            )
        else:
            search_context = "Результаты поиска не найдены."
        full_prompt = f"""Используйте следующие веб-результаты для ответа на пользовательский запрос:

{search_context}

Запрос: {prompt}"""

    response = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": full_prompt}],
        temperature=1,
    )

    return response.choices[0].message.content, model

```

```JSON
{
    "classification": "simple"
}
```

--------------------------------

### Запуск ADK Web UI (Bash)

Source: https://github.com/pridees/agentic-design-patterns-book-rus/blob/main/Часть 2/Глава 10. Протокол контекста модели.md

Команда для запуска ADK Web UI из терминала. Требуется перейти в родительскую директорию агента перед выполнением команды.

```Bash
cd ./adk_agent_samples # Или ваша эквивалентная родительская директория
adk web

```

--------------------------------

### Gemini CLI: Управление облачными ресурсами Google Cloud

Source: https://github.com/pridees/agentic-design-patterns-book-rus/blob/main/Приложения/Приложение E. AI Agents на CLI.md

Пример использования Gemini CLI для взаимодействия с Google Cloud Platform. Команда запрашивает информацию о кластерах GKE и генерирует команду `gcloud` для их обновления.

```Shell
Найдите все кластеры GKE в проекте `production`, которые работают на версиях старше 1.28, и сгенерируйте команду `gcloud` для их поочередного обновления.
```