---
title: Агент поддержки клиентов
url: https://platform.claude.com/docs/ru/about-claude/use-case-guides/customer-support-chat
description: Создайте чат-бота поддержки клиентов на базе Claude, который отвечает на вопросы о продуктах, придерживается темы и формирует расчёты стоимости с помощью использования инструментов.
---

## Предварительные требования

Чтобы следовать этому руководству, вам потребуется:

* Ключ API Claude (заданный в переменной окружения `ANTHROPIC_API_KEY`)
* Python 3.10 или новее

Установите необходимые пакеты:

```bash
pip install anthropic streamlit python-dotenv
```

## Прежде чем создавать решение с Claude

### Решите, стоит ли использовать Claude для чата поддержки

Вот несколько ключевых признаков того, что вам следует использовать «large language model» (большую языковую модель), или LLM, такую как Claude, для автоматизации части процесса поддержки клиентов:

<AccordionGroup>
  <Accordion title="Большой объём повторяющихся запросов">
    Claude отлично справляется с эффективной обработкой большого количества похожих вопросов, освобождая сотрудников поддержки для более сложных задач.
  </Accordion>

  <Accordion title="Потребность в быстром синтезе информации">
    Claude может быстро находить, обрабатывать и объединять информацию из обширных баз знаний, тогда как сотрудникам может потребоваться время на поиск или обращение к нескольким источникам.
  </Accordion>

  <Accordion title="Требование круглосуточной доступности">
    Claude может оказывать поддержку в любое время суток без усталости, тогда как обеспечение непрерывной работы сотрудников может быть дорогостоящим и сложным.
  </Accordion>

  <Accordion title="Быстрое масштабирование в пиковые периоды">
    Claude может справляться с внезапным ростом объёма запросов без необходимости нанимать и обучать дополнительный персонал.
  </Accordion>

  <Accordion title="Единый голос бренда">
    Вы можете поручить Claude последовательно передавать тон и ценности вашего бренда, тогда как стили общения сотрудников могут различаться.
  </Accordion>
</AccordionGroup>

Некоторые соображения в пользу выбора Claude среди других LLM:

* Вы отдаёте приоритет естественному, тонкому диалогу: развитое понимание языка позволяет Claude вести более естественные, учитывающие контекст беседы, которые ощущаются более человечными, чем чаты с другими LLM.
* Вы часто получаете сложные и открытые запросы: Claude может работать с широким кругом тем и вопросов, не генерируя шаблонные ответы и не требуя обширного программирования вариантов пользовательских высказываний.
* Вам нужна масштабируемая многоязычная поддержка: многоязычные возможности Claude позволяют вести беседы более чем на 200 языках без необходимости создавать отдельных чат-ботов или выстраивать обширные процессы перевода для каждого поддерживаемого языка.

### Определите идеальное взаимодействие в чате

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

Вот пример взаимодействия в чате поддержки клиентов по автострахованию:

* **Клиент:** Начинает чат поддержки
  * **Claude:** Тепло приветствует клиента и начинает беседу

* **Клиент:** Спрашивает о страховании своего нового электромобиля
  * **Claude:** Предоставляет релевантную информацию о страховом покрытии электромобилей

* **Клиент:** Задаёт вопросы, связанные с особыми потребностями страхования электромобилей
  * **Claude:** Даёт точные и информативные ответы и приводит ссылки на источники

* **Клиент:** Задаёт посторонние вопросы, не связанные со страхованием или автомобилями
  * **Claude:** Поясняет, что не обсуждает посторонние темы, и возвращает пользователя к теме автострахования

* **Клиент:** Выражает интерес к расчёту стоимости страховки

  * **Claude:** Задаёт ряд вопросов для определения подходящей стоимости, адаптируясь к ответам клиента
  * **Claude:** Отправляет запрос на использование инструмента API формирования расчёта вместе с необходимой информацией, собранной у пользователя
  * **Claude:** Получает ответную информацию от инструмента API, синтезирует её в естественный ответ и представляет пользователю полученный расчёт

* **Клиент:** Задаёт уточняющие вопросы

  * **Claude:** При необходимости отвечает на уточняющие вопросы
  * **Claude:** Направляет клиента к следующим шагам процесса страхования и завершает беседу

<Tip>
  В реальном примере, который вы напишете для своего сценария использования, может быть полезно записать конкретные слова этого взаимодействия, чтобы также понять идеальный тон, длину ответа и уровень детализации, которых вы ожидаете от Claude.
</Tip>

### Разбейте взаимодействие на отдельные задачи

Чат поддержки клиентов — это совокупность множества различных задач, от ответов на вопросы и поиска информации до выполнения действий по запросам, объединённых в одно взаимодействие с клиентом. Прежде чем приступать к разработке, разбейте идеальное взаимодействие с клиентом на все задачи, которые Claude должен уметь выполнять. Это гарантирует, что вы сможете составить подсказки и оценить Claude по каждой задаче, а также даст хорошее представление о диапазоне взаимодействий, которые нужно учесть при написании тестовых случаев.

<Tip>
  Клиентам иногда помогает визуализировать это в виде блок-схемы взаимодействия с возможными точками ветвления беседы в зависимости от запросов пользователя.
</Tip>

Вот ключевые задачи, связанные с примером взаимодействия по страхованию:

1. Приветствие и общие рекомендации

   * Тепло поприветствовать клиента и начать беседу
   * Предоставить общую информацию о компании и взаимодействии

2. Информация о продукте

   * Предоставить информацию о страховом покрытии электромобилей
     <Note>
       Для этого потребуется, чтобы у Claude была необходимая информация в контексте, и это может означать необходимость 

       [интеграции RAG](https://platform.claude.com/cookbook/capabilities-retrieval-augmented-generation-guide)

       .
     </Note>
   * Отвечать на вопросы, связанные с особыми потребностями страхования электромобилей
   * Отвечать на уточняющие вопросы о расчёте или деталях страхования
   * Предлагать ссылки на источники, когда это уместно

3. Управление беседой

   * Придерживаться темы (автострахование)
   * Перенаправлять посторонние вопросы обратно к релевантным темам

4. Формирование расчёта

   * Задавать подходящие вопросы для определения возможности расчёта
   * Адаптировать вопросы в зависимости от ответов клиента
   * Передавать собранную информацию в API формирования расчёта
   * Представлять клиенту полученный расчёт

### Установите критерии успеха

Совместно с вашей командой поддержки [определите критерии успеха и напишите подробные оценки](https://platform.claude.com/docs/ru/test-and-evaluate/develop-tests) с измеримыми ориентирами и целями.

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

<AccordionGroup>
  <Accordion title="Точность понимания запросов">
    Эта метрика оценивает, насколько точно Claude интерпретирует запросы клиентов по различным темам. Измеряйте её, просматривая выборку бесед и оценивая, правильно ли Claude понимает намерение клиента, важные следующие шаги, то, как выглядит успешное решение, и многое другое. Стремитесь к точности понимания 95 процентов или выше.
  </Accordion>

  <Accordion title="Релевантность ответов">
    Оценивает, насколько хорошо ответ Claude отвечает на конкретный вопрос или проблему клиента. Оцените набор бесед и определите релевантность каждого ответа (используя оценку на основе LLM для масштабирования). Целевой показатель релевантности — 90 процентов или выше.
  </Accordion>

  <Accordion title="Точность ответов">
    Оценивайте правильность общей информации о компании и продуктах, предоставляемой пользователю, на основе информации, переданной Claude в контексте. Целевой показатель — 100 процентов точности этой вводной информации.
  </Accordion>

  <Accordion title="Релевантность предоставляемых ссылок">
    Отслеживайте частоту и релевантность предлагаемых ссылок или источников. Цель — предоставлять релевантные источники в 80 процентах взаимодействий, в которых дополнительная информация может быть полезна.
  </Accordion>

  <Accordion title="Соблюдение темы">
    Измеряйте, насколько хорошо Claude придерживается темы, например темы автострахования в примере реализации. Стремитесь к тому, чтобы 95 процентов ответов были напрямую связаны с автострахованием или конкретным запросом клиента.
  </Accordion>

  <Accordion title="Эффективность генерации контента">
    Измеряйте, насколько успешно Claude определяет, когда следует генерировать информационный контент, и насколько этот контент релевантен. Например, в этой реализации вы определяли бы, насколько хорошо Claude понимает, когда нужно сформировать расчёт стоимости, и насколько этот расчёт точен. Целевой показатель — 100 процентов точности, так как это жизненно важная информация для успешного взаимодействия с клиентом.
  </Accordion>

  <Accordion title="Эффективность эскалации">
    Измеряет способность Claude распознавать, когда запрос требует вмешательства человека, и надлежащим образом передавать его. Отслеживайте процент правильно переданных бесед по сравнению с теми, которые следовало передать, но этого не было сделано. Стремитесь к точности эскалации 95 процентов или выше.
  </Accordion>
</AccordionGroup>

Вот критерии и ориентиры, которые можно использовать для оценки влияния на бизнес от применения Claude в поддержке:

<AccordionGroup>
  <Accordion title="Поддержание настроения">
    Оценивает способность Claude сохранять или улучшать настроение клиента на протяжении беседы. Используйте инструменты анализа тональности для измерения настроения в начале и в конце каждой беседы. Стремитесь к сохранению или улучшению настроения в 90 процентах взаимодействий.
  </Accordion>

  <Accordion title="Доля самостоятельно решённых обращений">
    Процент запросов клиентов, успешно обработанных чат-ботом без вмешательства человека. Обычно цель — 70–80 процентов, в зависимости от сложности запросов.
  </Accordion>

  <Accordion title="Оценка удовлетворённости клиентов">
    Показатель того, насколько клиенты удовлетворены взаимодействием с чат-ботом. Обычно измеряется с помощью опросов после взаимодействия. Стремитесь к оценке CSAT 4 из 5 или выше.
  </Accordion>

  <Accordion title="Среднее время обработки">
    Среднее время, необходимое чат-боту для решения запроса. Оно сильно варьируется в зависимости от сложности проблем, но в целом стремитесь к более низкому AHT по сравнению с сотрудниками.
  </Accordion>
</AccordionGroup>

## Как реализовать Claude в роли агента службы поддержки

### Выберите подходящую модель Claude

Выбор модели зависит от компромиссов между стоимостью, точностью и временем ответа.

Для чата поддержки клиентов Claude Opus 5.5 хорошо подходит для баланса интеллекта, «latency» (задержки) и стоимости, включая самые сложные сценарии поддержки, требующие глубоких рассуждений в длинных многошаговых беседах. Однако в случаях, когда у вас есть поток беседы с несколькими подсказками, включая RAG, использование инструментов или подсказки с длинным контекстом, Claude Haiku 5.5 может лучше подойти для оптимизации задержки. [Уровень усилий](https://platform.claude.com/docs/ru/build-with-claude/effort) — его основной инструмент управления скоростью: `low` — самый быстрый уровень, подходящий для чата и коротких задач с инструментами.

### Составьте сильную подсказку

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

Начните с написания элементов сильной подсказки, начиная с «system prompt» (системной подсказки). Создайте файл `config.py` и добавьте в него каждый из следующих блоков:

```python
IDENTITY = """You are Eva, a friendly and knowledgeable AI assistant for Acme Insurance
Company. Your role is to warmly welcome customers and provide information on
Acme's insurance offerings, which include car insurance and electric car
insurance. You can also help customers get quotes for their insurance needs."""
```

<Tip>
  Хотя может возникнуть соблазн поместить всю информацию в системную подсказку, чтобы отделить инструкции от беседы с пользователем, Claude на самом деле работает лучше всего, когда основная часть содержимого подсказки написана в первом ходе 

  `User`

   (единственное исключение — назначение роли). Подробнее читайте в разделе 

  [Назначение роли Claude с помощью системной подсказки](https://platform.claude.com/docs/ru/build-with-claude/prompt-engineering/claude-prompting-best-practices#give-claude-a-role)

  .
</Tip>

Сложные подсказки лучше разбивать на подразделы и писать по одной части за раз. Для каждой задачи вы можете добиться большего успеха, следуя пошаговому процессу определения частей подсказки, которые понадобятся Claude для качественного выполнения задачи. В этом примере поддержки клиентов по автострахованию вы будете по частям писать все элементы подсказки, начиная с задачи «Приветствие и общие рекомендации». Это также упрощает отладку подсказки, поскольку вы можете быстрее корректировать отдельные части общей подсказки.

```python
STATIC_GREETINGS_AND_GENERAL = """
<static_context>
Acme Auto Insurance: Your Trusted Companion on the Road

About:
At Acme Insurance, we understand that your vehicle is more than just a mode of transportation—it's your ticket to life's adventures.
Since 1985, we've been crafting auto insurance policies that give drivers the confidence to explore, commute, and travel with peace of mind.
Whether you're navigating city streets or embarking on cross-country road trips, Acme is there to protect you and your vehicle.
Our innovative auto insurance policies are designed to adapt to your unique needs, covering everything from fender benders to major collisions.
With Acme's award-winning customer service and swift claim resolution, you can focus on the joy of driving while we handle the rest.
We're not just an insurance provider—we're your co-pilot in life's journeys.
Choose Acme Auto Insurance and experience the assurance that comes with superior coverage and genuine care. Because at Acme, we don't just
insure your car—we fuel your adventures on the open road.

Note: We also offer specialized coverage for electric vehicles, ensuring that drivers of all car types can benefit from our protection.

Acme Insurance offers the following products:
- Car insurance
- Electric car insurance
- Two-wheeler insurance

Business hours: Monday-Friday, 9 AM - 5 PM EST
Customer service number: 1-800-123-4567
</static_context>
"""
```

Затем сделайте то же самое для информации об автостраховании и страховании электромобилей.

```python
STATIC_CAR_INSURANCE = """
<static_context>
Car Insurance Coverage:
Acme's car insurance policies typically cover:
1. Liability coverage: Pays for bodily injury and property damage you cause to others.
2. Collision coverage: Pays for damage to your car in an accident.
3. Comprehensive coverage: Pays for damage to your car from non-collision incidents.
4. Medical payments coverage: Pays for medical expenses after an accident.
5. Uninsured/underinsured motorist coverage: Protects you if you're hit by a driver with insufficient insurance.

Optional coverages include:
- Rental car reimbursement
- Roadside assistance
- New car replacement
</static_context>
"""

STATIC_ELECTRIC_CAR_INSURANCE = """
<static_context>
Electric Car Insurance:
Our specialized electric car insurance goes beyond traditional auto coverage,
offering tailored protection for your high-tech investment. In addition to standard coverages, we offer:
- Safeguarding expensive battery systems
- Covering home charging equipment
- Adapting to the rapidly evolving world of electric vehicles

Whether you're driving a Rivian, Nissan Leaf, Chevrolet Bolt,
or any other electric vehicle, our knowledgeable agents are ready to craft a policy
that gives you the confidence to enjoy every electron-powered mile.
</static_context>
"""
```

Теперь, когда у вас есть статический контент, добавьте как минимум 4–5 примеров «хороших» взаимодействий, чтобы направлять ответы Claude. Эти примеры должны быть репрезентативными для вашего идеального взаимодействия с клиентом и могут включать такие элементы, как ограничения и вызовы инструментов.

```python
EXAMPLES = """
Here are a few examples of how you can interact with customers:

<example 1>
H: Hi, do you offer commercial insurance for small businesses?

A: Ah! Unfortunately, we don't offer commercial insurance at this time.
However, we do provide a range of personal insurance products including car insurance and electric car insurance.
Would you like to know more about these offerings?
</example 1>

<example 2>
H: Hi, what are your business hours?

A: Our business hours are Monday to Friday, 9 AM to 5 PM EST.
If you have any questions or need assistance, feel free to reach out during those times.
How else can I assist you today?
</example 2>

<example 3>
H: I'm shopping for car insurance. What does Acme offer?

A: Great choice! Acme's car insurance policies typically include:
- Liability coverage: Protects you if you're at fault in an accident
- Collision coverage: Pays for damage to your car in an accident
- Comprehensive coverage: Covers non-collision incidents like theft or vandalism
- Medical payments coverage: Pays for medical expenses after an accident
- Uninsured/underinsured motorist coverage: Protects you from drivers with insufficient insurance

We also offer optional coverages like rental car reimbursement, roadside assistance, and new car replacement.
Would you like more details on any of these coverages, or do you have specific questions about insuring your vehicle?
</example 3>

<example 4>
H: I'd like to hear about your electric car insurance.

A: Certainly! Our electric car insurance is specially designed to meet the unique needs of electric vehicle owners.
In addition to all the standard coverages we offer for regular cars, our electric car policies include:

- Battery coverage: Protection against damage or degradation of your vehicle's expensive battery system
- Tech package: Covers repairs or replacement of advanced electronics and onboard computer systems
- Charging station coverage: Protects both home and portable charging equipment
- Cybersecurity protection: Coverage against hacking or digital threats
- Specialized roadside assistance: Includes flatbed towing to protect the vehicle's undercarriage

We cover a wide range of electric vehicles, including popular models from Tesla, Rivian, Nissan, Chevrolet, and more.
Is there a specific electric vehicle you're looking to insure, or would you like more details on any of these coverages?
</example 4>

<example 5>
H: I'd like to get a quote for my car insurance.

A: Certainly! I'd be happy to help you get a quote for your car insurance.
To provide you with an accurate quote, I'll need to collect some information about your vehicle and the primary driver.
Let's start with the basics:

1. What is the make and model of your vehicle?
2. What year was it manufactured?
3. Approximately how many miles have you driven?
4. What is the age of the primary driver?

Once you provide this information, I'll use our quoting tool to generate a personalized insurance quote for you.
</example 5>
"""
```

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

```python
ADDITIONAL_GUARDRAILS = """Please adhere to the following guardrails:
1. Only provide information about insurance types listed in our offerings.
2. If asked about an insurance type we don't offer, politely state
that we don't provide that service.
3. Do not speculate about future product offerings or company plans.
4. Don't make promises or enter into agreements it's not authorized to make.
You only provide information and guidance.
5. Do not mention any competitor's products or services.
"""
```

Теперь объедините все эти разделы в одну строку, которая будет использоваться в качестве подсказки.

```python
TASK_SPECIFIC_INSTRUCTIONS = " ".join(
    [
        STATIC_GREETINGS_AND_GENERAL,
        STATIC_CAR_INSURANCE,
        STATIC_ELECTRIC_CAR_INSURANCE,
        EXAMPLES,
        ADDITIONAL_GUARDRAILS,
    ]
)
```

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

Claude способен выполнять действия и динамически извлекать информацию с помощью функциональности «tool use» (использования инструментов) на стороне клиента. Начните с перечисления всех внешних инструментов или API, которые должна использовать подсказка.

В этом примере начните с одного инструмента для расчёта стоимости.

<Tip>
  Напоминаем, что этот инструмент не выполняет фактический расчёт; он лишь сигнализирует приложению, что следует использовать инструмент с аргументами, которые указывает Claude.
</Tip>

Добавьте в `config.py` имя модели, определение инструмента и заглушку реализации:

```python
import time

MODEL = "claude-opus-5-5"

TOOLS = [
    {
        "name": "get_quote",
        "description": "Calculate the insurance quote based on user input. Returned value is per month premium.",
        "input_schema": {
            "type": "object",
            "properties": {
                "make": {"type": "string", "description": "The make of the vehicle."},
                "model": {"type": "string", "description": "The model of the vehicle."},
                "year": {
                    "type": "integer",
                    "description": "The year the vehicle was manufactured.",
                },
                "mileage": {
                    "type": "integer",
                    "description": "The mileage on the vehicle.",
                },
                "driver_age": {
                    "type": "integer",
                    "description": "The age of the primary driver.",
                },
            },
            "required": ["make", "model", "year", "mileage", "driver_age"],
        },
    }
]


def get_quote(make, model, year, mileage, driver_age):
    """Returns the premium per month in USD"""
    # Для получения котировки можно вызвать HTTP-эндпоинт или обратиться к базе данных.
    # Этот пример имитирует задержку в 1 секунду и возвращает фиксированную котировку 100.
    time.sleep(1)
    return 100
```

### Разверните ваши подсказки

Трудно понять, насколько хорошо работает ваша подсказка, не развернув её в тестовой производственной среде и не [проведя оценки](https://platform.claude.com/docs/ru/test-and-evaluate/develop-tests). Создайте небольшое приложение, используя подсказку, Anthropic SDK и Streamlit для пользовательского интерфейса.

В файле `chatbot.py` (или эквивалентном модуле на вашем языке) настройте класс ChatBot, который будет инкапсулировать взаимодействие с Anthropic SDK.

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

<CodeGroup exclude="shell">
  ```python Python
  # В вашем chatbot.py импортируйте это из config.py, написанного ранее:
  # from config import IDENTITY, TOOLS, MODEL, get_quote
  from anthropic import Anthropic
  from dotenv import load_dotenv

  load_dotenv()


  class ChatBot:
      def __init__(self, session_state):
          self.anthropic = Anthropic()
          self.session_state = session_state

      def generate_message(
          self,
          messages,
          max_tokens,
      ):
          try:
              response = self.anthropic.messages.create(
                  model=MODEL,
                  system=IDENTITY,
                  max_tokens=max_tokens,
                  messages=messages,
                  tools=TOOLS,
              )
              return response
          except Exception as e:
              return {"error": str(e)}

      def process_user_input(self, user_input):
          self.session_state.messages.append({"role": "user", "content": user_input})

          response_message = self.generate_message(
              messages=self.session_state.messages,
              max_tokens=2048,
          )

          if "error" in response_message:
              return f"An error occurred: {response_message['error']}"

          if response_message.content[-1].type == "tool_use":
              tool_use = response_message.content[-1]
              func_name = tool_use.name
              func_params = tool_use.input
              tool_use_id = tool_use.id

              result = self.handle_tool_use(func_name, func_params)
              self.session_state.messages.append(
                  {"role": "assistant", "content": response_message.content}
              )
              self.session_state.messages.append(
                  {
                      "role": "user",
                      "content": [
                          {
                              "type": "tool_result",
                              "tool_use_id": tool_use_id,
                              "content": f"{result}",
                          }
                      ],
                  }
              )

              follow_up_response = self.generate_message(
                  messages=self.session_state.messages,
                  max_tokens=2048,
              )

              if "error" in follow_up_response:
                  return f"An error occurred: {follow_up_response['error']}"

              response_text = next(
                  (
                      block.text
                      for block in follow_up_response.content
                      if block.type == "text"
                  ),
                  None,
              )
              if response_text is None:
                  raise Exception("An error occurred: Unexpected response type")
              self.session_state.messages.append(
                  {"role": "assistant", "content": response_text}
              )
              return response_text

          text_block = next(
              (block for block in response_message.content if block.type == "text"), None
          )
          if text_block is not None:
              response_text = text_block.text
              self.session_state.messages.append(
                  {"role": "assistant", "content": response_text}
              )
              return response_text

          raise Exception("An error occurred: Unexpected response type")

      def handle_tool_use(self, func_name, func_params):
          if func_name == "get_quote":
              premium = get_quote(**func_params)
              return f"Quote generated: ${premium:.2f} per month"

          raise Exception("An unexpected tool was used")
  ```

  ```typescript TypeScript
  import Anthropic from "@anthropic-ai/sdk";

  class ChatBot {
    // IDENTITY, MODEL, TOOLS и getQuote повторяют значения из config.py, определённые
    // ранее в этом руководстве (показаны на Python).
    readonly anthropic = new Anthropic();
    readonly messages: Anthropic.MessageParam[] = [];

    async generateMessage(
      messages: Anthropic.MessageParam[],
      maxTokens: number
    ): Promise<Anthropic.Message> {
      return this.anthropic.messages.create({
        model: MODEL,
        system: IDENTITY,
        max_tokens: maxTokens,
        messages,
        tools: TOOLS
      });
    }

    async processUserInput(userInput: string): Promise<string> {
      this.messages.push({ role: "user", content: userInput });

      const responseMessage = await this.generateMessage(this.messages, 2048);

      const lastBlock = responseMessage.content.at(-1);
      if (lastBlock?.type === "tool_use") {
        const toolResult = this.handleToolUse(lastBlock.name, lastBlock.input);

        this.messages.push({ role: "assistant", content: responseMessage.content });
        this.messages.push({
          role: "user",
          content: [{ type: "tool_result", tool_use_id: lastBlock.id, content: toolResult }]
        });

        const followUpResponse = await this.generateMessage(this.messages, 2048);

        const followUpBlock = followUpResponse.content.find((block) => block.type === "text");
        if (!followUpBlock) {
          throw new Error("An error occurred: Unexpected response type");
        }
        this.messages.push({ role: "assistant", content: followUpBlock.text });
        return followUpBlock.text;
      }

      const firstBlock = responseMessage.content.find((block) => block.type === "text");
      if (firstBlock) {
        this.messages.push({ role: "assistant", content: firstBlock.text });
        return firstBlock.text;
      }

      throw new Error("An error occurred: Unexpected response type");
    }

    handleToolUse(toolName: string, toolInput: unknown): string {
      if (toolName === "get_quote") {
        // SDK типизирует tool_use.input как unknown; сужаем тип до схемы get_quote.
        if (
          toolInput === null ||
          typeof toolInput !== "object" ||
          !("make" in toolInput) ||
          typeof toolInput.make !== "string" ||
          !("model" in toolInput) ||
          typeof toolInput.model !== "string" ||
          !("year" in toolInput) ||
          typeof toolInput.year !== "number" ||
          !("mileage" in toolInput) ||
          typeof toolInput.mileage !== "number" ||
          !("driver_age" in toolInput) ||
          typeof toolInput.driver_age !== "number"
        ) {
          throw new Error("An error occurred: Unexpected tool input");
        }
        const { make, model: vehicleModel, year, mileage, driver_age: driverAge } = toolInput;

        const premium = getQuote(make, vehicleModel, year, mileage, driverAge);
        return `Quote generated: $${premium.toFixed(2)} per month`;
      }

      throw new Error("An unexpected tool was used");
    }
  }
  ```

  ```csharp C#
  using System.Text.Json;
  using Anthropic;
  using Anthropic.Models.Messages;

  // Config.Model, Config.Identity, Config.Tools и Config.GetQuote повторяют
  // значения из config.py, определённые ранее в этом руководстве (показаны на Python).
  public class ChatBot
  {
      private readonly AnthropicClient _anthropic = new();

      public List<MessageParam> Messages { get; } = [];

      public async Task<Message> GenerateMessage(List<MessageParam> messages, long maxTokens) =>
          await _anthropic.Messages.Create(
              new MessageCreateParams
              {
                  Model = Config.Model,
                  System = Config.Identity,
                  MaxTokens = maxTokens,
                  Messages = messages,
                  Tools = Config.Tools,
              }
          );

      public async Task<string> ProcessUserInput(string userInput)
      {
          Messages.Add(new UserMessageParam { Content = userInput });

          var responseMessage = await GenerateMessage(Messages, maxTokens: 2048);

          if (responseMessage.Content[^1].TryPickToolUse(out var toolUse))
          {
              var toolResult = HandleToolUse(toolUse.Name, toolUse.Input);

              Messages.Add(new AssistantMessageParam
              {
                  Content = responseMessage.Content
                      .Select(contentBlock => new ContentBlockParam(contentBlock.Json))
                      .ToList(),
              });
              Messages.Add(new UserMessageParam
              {
                  Content = new List<ContentBlockParam>
                  {
                      new ToolResultBlockParam { ToolUseID = toolUse.ID, Content = toolResult },
                  },
              });

              var followUpResponse = await GenerateMessage(Messages, maxTokens: 2048);

              foreach (var block in followUpResponse.Content)
              {
                  if (block.TryPickText(out var followUpText))
                  {
                      Messages.Add(new AssistantMessageParam { Content = followUpText.Text });
                      return followUpText.Text;
                  }
              }

              throw new InvalidOperationException("An error occurred: Unexpected response type");
          }

          foreach (var block in responseMessage.Content)
          {
              if (block.TryPickText(out var textBlock))
              {
                  Messages.Add(new AssistantMessageParam { Content = textBlock.Text });
                  return textBlock.Text;
              }
          }

          throw new InvalidOperationException("An error occurred: Unexpected response type");
      }

      public string HandleToolUse(string funcName, IReadOnlyDictionary<string, JsonElement> funcParams)
      {
          if (funcName == "get_quote")
          {
              var premium = Config.GetQuote(
                  funcParams["make"].GetString()!,
                  funcParams["model"].GetString()!,
                  funcParams["year"].GetInt64(),
                  funcParams["mileage"].GetInt64(),
                  funcParams["driver_age"].GetInt64()
              );
              return $"Quote generated: ${premium:F2} per month";
          }

          throw new ArgumentException("An unexpected tool was used");
      }
  }
  ```

  ```go Go
  import (
  	"context"
  	"encoding/json"
  	"fmt"

  	"github.com/anthropics/anthropic-sdk-go/v2"
  )

  // ChatBot оборачивает клиент Anthropic и историю диалога. Используемые им
  // значения identity, model, tools и getQuote повторяют определения из config.py,
  // приведённые ранее в этом руководстве (показаны на Python).
  type ChatBot struct {
  	client   anthropic.Client
  	messages []anthropic.MessageParam
  }

  func NewChatBot() *ChatBot {
  	return &ChatBot{client: anthropic.NewClient()}
  }

  func (bot *ChatBot) GenerateMessage(ctx context.Context, messages []anthropic.MessageParam, maxTokens int64) (*anthropic.Message, error) {
  	return bot.client.Messages.New(ctx, anthropic.MessageNewParams{
  		Model:     model,
  		System:    []anthropic.TextBlockParam{{Text: identity}},
  		MaxTokens: maxTokens,
  		Messages:  messages,
  		Tools:     tools,
  	})
  }

  func (bot *ChatBot) ProcessUserInput(ctx context.Context, userInput string) (string, error) {
  	bot.messages = append(bot.messages, anthropic.NewUserMessage(anthropic.NewTextBlock(userInput)))

  	response, err := bot.GenerateMessage(ctx, bot.messages, 2048)
  	if err != nil {
  		return "", err
  	}

  	lastBlock := response.Content[len(response.Content)-1]
  	if toolUse, ok := lastBlock.AsAny().(anthropic.ToolUseBlock); ok {
  		result, err := bot.HandleToolUse(toolUse.Name, toolUse.Input)
  		if err != nil {
  			return "", err
  		}

  		bot.messages = append(bot.messages,
  			response.ToParam(),
  			anthropic.NewUserMessage(anthropic.NewToolResultBlock(toolUse.ID, result, false)),
  		)

  		followUp, err := bot.GenerateMessage(ctx, bot.messages, 2048)
  		if err != nil {
  			return "", err
  		}

  		for _, block := range followUp.Content {
  			if textBlock, ok := block.AsAny().(anthropic.TextBlock); ok {
  				bot.messages = append(bot.messages, anthropic.NewAssistantMessage(anthropic.NewTextBlock(textBlock.Text)))
  				return textBlock.Text, nil
  			}
  		}
  		return "", fmt.Errorf("an error occurred: unexpected response type")
  	}

  	for _, block := range response.Content {
  		if textBlock, ok := block.AsAny().(anthropic.TextBlock); ok {
  			bot.messages = append(bot.messages, anthropic.NewAssistantMessage(anthropic.NewTextBlock(textBlock.Text)))
  			return textBlock.Text, nil
  		}
  	}

  	return "", fmt.Errorf("an error occurred: unexpected response type")
  }

  func (bot *ChatBot) HandleToolUse(toolName string, toolInput json.RawMessage) (string, error) {
  	if toolName != "get_quote" {
  		return "", fmt.Errorf("an unexpected tool was used: %s", toolName)
  	}

  	var input struct {
  		Make      string `json:"make"`
  		Model     string `json:"model"`
  		Year      int    `json:"year"`
  		Mileage   int    `json:"mileage"`
  		DriverAge int    `json:"driver_age"`
  	}
  	if err := json.Unmarshal(toolInput, &input); err != nil {
  		return "", err
  	}
  	premium := getQuote(input.Make, input.Model, input.Year, input.Mileage, input.DriverAge)
  	return fmt.Sprintf("Quote generated: $%.2f per month", premium), nil
  }
  ```

  ```java Java
  import com.anthropic.client.AnthropicClient;
  import com.anthropic.client.okhttp.AnthropicOkHttpClient;
  import com.anthropic.core.JsonValue;
  import com.anthropic.models.messages.ContentBlock;
  import com.anthropic.models.messages.ContentBlockParam;
  import com.anthropic.models.messages.Message;
  import com.anthropic.models.messages.MessageCreateParams;
  import com.anthropic.models.messages.MessageParam;
  import com.anthropic.models.messages.ToolResultBlockParam;
  import com.anthropic.models.messages.ToolUseBlock;

  // IDENTITY, MODEL, TOOLS и getQuote повторяют значения из config.py, определённые
  // ранее в этом руководстве (показаны на Python).
  class ChatBot {
      final AnthropicClient anthropic;
      final List<MessageParam> messages;

      ChatBot() {
          // Считывает ключ API из переменной окружения ANTHROPIC_API_KEY
          this.anthropic = AnthropicOkHttpClient.fromEnv();
          this.messages = new ArrayList<>();
      }

      Message generateMessage(List<MessageParam> messages, long maxTokens) {
          return anthropic.messages().create(MessageCreateParams.builder()
              .model(MODEL)
              .system(IDENTITY)
              .maxTokens(maxTokens)
              .messages(messages)
              .tools(TOOLS)
              .build());
      }

      String processUserInput(String userInput) {
          messages.add(MessageParam.ofUser(userInput));

          Message responseMessage = generateMessage(messages, 2048);

          List<ContentBlock> content = responseMessage.content();
          ContentBlock lastBlock = content.getLast();
          if (lastBlock.isToolUse()) {
              ToolUseBlock toolUse = lastBlock.asToolUse();
              Map<String, JsonValue> toolInput =
                  (Map<String, JsonValue>) toolUse._input().asObject().orElseThrow();
              String result = handleToolUse(toolUse.name(), toolInput);

              messages.add(MessageParam.ofAssistantOfContentBlockParams(
                  content.stream().map(ContentBlock::toParam).toList()));
              messages.add(MessageParam.ofUserOfContentBlockParams(List.of(ContentBlockParam.ofToolResult(
                  ToolResultBlockParam.builder()
                      .toolUseId(toolUse.id())
                      .content(result)
                      .build()))));

              Message followUpResponse = generateMessage(messages, 2048);

              ContentBlock followUpBlock = followUpResponse.content().stream()
                  .filter(ContentBlock::isText)
                  .findFirst()
                  .orElseThrow(() -> new IllegalStateException("An error occurred: Unexpected response type"));
              String responseText = followUpBlock.asText().text();
              messages.add(MessageParam.ofAssistant(responseText));
              return responseText;
          } else {
              ContentBlock textBlock = content.stream()
                  .filter(ContentBlock::isText)
                  .findFirst()
                  .orElseThrow(() -> new IllegalStateException("An error occurred: Unexpected response type"));
              String responseText = textBlock.asText().text();
              messages.add(MessageParam.ofAssistant(responseText));
              return responseText;
          }
      }

      String handleToolUse(String funcName, Map<String, JsonValue> funcParams) {
          return switch (funcName) {
              case "get_quote" -> {
                  double premium = getQuote(
                      funcParams.get("make").asStringOrThrow(),
                      funcParams.get("model").asStringOrThrow(),
                      ((Number) funcParams.get("year").asNumber().orElseThrow()).longValue(),
                      ((Number) funcParams.get("mileage").asNumber().orElseThrow()).longValue(),
                      ((Number) funcParams.get("driver_age").asNumber().orElseThrow()).longValue());
                  yield "Quote generated: $%.2f per month".formatted(premium);
              }
              default -> throw new IllegalArgumentException("An unexpected tool was used");
          };
      }
  }
  ```

  ```php PHP
  use Anthropic\Client;
  use Anthropic\Messages\AssistantMessageParam;
  use Anthropic\Messages\Message;
  use Anthropic\Messages\TextBlock;
  use Anthropic\Messages\ToolResultBlockParam;
  use Anthropic\Messages\ToolUseBlock;
  use Anthropic\Messages\UserMessageParam;

  class ChatBot
  {
      // MODEL, IDENTITY, TOOLS и get_quote() повторяют значения из config.py,
      // определённые ранее в этом руководстве (показаны на Python).

      /** @var list<UserMessageParam|AssistantMessageParam> */
      public private(set) array $messages = [];

      public function __construct(
          private readonly Client $anthropic = new Client(),
      ) {}

      /**
       * @param list<UserMessageParam|AssistantMessageParam> $messages
       */
      public function generateMessage(array $messages, int $maxTokens): Message
      {
          return $this->anthropic->messages->create(
              model: MODEL,
              system: IDENTITY,
              maxTokens: $maxTokens,
              messages: $messages,
              tools: TOOLS,
          );
      }

      public function processUserInput(string $userInput): string
      {
          $this->messages[] = UserMessageParam::with(content: $userInput);

          $responseMessage = $this->generateMessage($this->messages, maxTokens: 2048);

          $content = $responseMessage->content;
          $lastBlock = array_last($content);

          if ($lastBlock instanceof ToolUseBlock) {
              $toolResult = $this->handleToolUse($lastBlock->name, $lastBlock->input);

              $this->messages[] = AssistantMessageParam::with(content: $content);
              $this->messages[] = UserMessageParam::with(
                  content: [
                      ToolResultBlockParam::with(toolUseID: $lastBlock->id, content: $toolResult),
                  ],
              );

              $followUpResponse = $this->generateMessage($this->messages, maxTokens: 2048);

              $firstBlock = array_find(
                  $followUpResponse->content,
                  static fn ($block): bool => $block instanceof TextBlock,
              );
              if (!$firstBlock instanceof TextBlock) {
                  throw new \RuntimeException('An error occurred: Unexpected response type');
              }

              $this->messages[] = AssistantMessageParam::with(content: $firstBlock->text);

              return $firstBlock->text;
          }

          $firstBlock = array_find($content, static fn ($block): bool => $block instanceof TextBlock);
          if ($firstBlock instanceof TextBlock) {
              $this->messages[] = AssistantMessageParam::with(content: $firstBlock->text);

              return $firstBlock->text;
          }

          throw new \RuntimeException('An error occurred: Unexpected response type');
      }

      /**
       * @param array<string, mixed> $funcParams
       */
      private function handleToolUse(string $funcName, array $funcParams): string
      {
          if ($funcName === 'get_quote') {
              $premium = get_quote(...$funcParams);

              return sprintf('Quote generated: $%.2f per month', $premium);
          }

          throw new \RuntimeException('An unexpected tool was used');
      }
  }
  ```

  ```ruby Ruby
  # IDENTITY, MODEL, TOOLS и get_quote повторяют значения из config.py, определённые
  # ранее в этом руководстве (показаны на Python).
  require "anthropic"

  class ChatBot
    attr_reader :messages

    def initialize
      @anthropic = Anthropic::Client.new
      @messages = []
    end

    def generate_message(messages, max_tokens)
      @anthropic.messages.create(
        model: MODEL,
        system_: IDENTITY,
        max_tokens:,
        messages:,
        tools: TOOLS
      )
    end

    def process_user_input(user_input)
      @messages << {role: "user", content: user_input}

      response_message = generate_message(@messages, 2048)

      case response_message.content
      in [*, Anthropic::ToolUseBlock => tool_use]
        result = handle_tool_use(tool_use.name, tool_use.input)
        @messages << {role: "assistant", content: response_message.content}
        @messages << {
          role: "user",
          content: [{type: "tool_result", tool_use_id: tool_use.id, content: result}]
        }

        follow_up_response = generate_message(@messages, 2048)

        case follow_up_response.content
        in [*, Anthropic::TextBlock => text_block, *]
          @messages << {role: "assistant", content: text_block.text}
          text_block.text
        else
          raise "An error occurred: Unexpected response type"
        end
      in [*, Anthropic::TextBlock => text_block, *]
        @messages << {role: "assistant", content: text_block.text}
        text_block.text
      else
        raise "An error occurred: Unexpected response type"
      end
    end

    def handle_tool_use(tool_name, tool_input)
      raise "An unexpected tool was used" unless tool_name == "get_quote"

      premium = get_quote(**tool_input)
      format("Quote generated: $%.2f per month", premium)
    end
  end
  ```
</CodeGroup>

### Создайте пользовательский интерфейс

Протестируйте развёртывание этого кода со Streamlit с помощью функции main. Эта функция `main()` настраивает интерфейс чата на базе Streamlit. Streamlit — это фреймворк для Python, поэтому эта часть руководства показана только на Python; класс ChatBot, показанный ранее, — это та часть, которую можно перенести на любой язык.

Сделайте это в файле `app.py`:

```python
import streamlit as st
from chatbot import ChatBot
from config import TASK_SPECIFIC_INSTRUCTIONS


def main():
    st.title("Chat with Eva, Acme Insurance Company's Assistant🤖")

    if "messages" not in st.session_state:
        st.session_state.messages = [
            {"role": "user", "content": TASK_SPECIFIC_INSTRUCTIONS},
            {"role": "assistant", "content": "Understood"},
        ]

    chatbot = ChatBot(st.session_state)

    # Отображаем сообщения пользователя и ассистента, пропуская первые два
    for message in st.session_state.messages[2:]:
        # игнорируем блоки использования инструментов
        if isinstance(message["content"], str):
            with st.chat_message(message["role"]):
                st.markdown(message["content"])

    if user_msg := st.chat_input("Type your message here..."):
        st.chat_message("user").markdown(user_msg)

        with st.chat_message("assistant"):
            with st.spinner("Eva is thinking..."):
                response_placeholder = st.empty()
                full_response = chatbot.process_user_input(user_msg)
                response_placeholder.markdown(full_response)


if __name__ == "__main__":
    main()
```

Запустите программу командой:

```bash
streamlit run app.py
```

### Оцените ваши подсказки

Подсказки часто требуют тестирования и оптимизации, чтобы быть готовыми к производственному использованию. Чтобы определить готовность вашего решения, оцените работу чат-бота с помощью систематического процесса, сочетающего количественные и качественные методы. Создание [надёжной эмпирической оценки](https://platform.claude.com/docs/ru/test-and-evaluate/develop-tests#build-evaluations) на основе определённых вами критериев успеха позволит оптимизировать ваши подсказки.

### Улучшите производительность

В сложных сценариях может быть полезно рассмотреть дополнительные стратегии улучшения производительности помимо стандартных [техник инженерии подсказок](https://platform.claude.com/docs/ru/build-with-claude/prompt-engineering/overview) и [стратегий внедрения ограничений](https://platform.claude.com/docs/ru/test-and-evaluate/strengthen-guardrails/reduce-hallucinations). Вот несколько распространённых сценариев:

#### Снизьте задержку при длинном контексте с помощью RAG

При работе с большими объёмами статического и динамического контекста включение всей информации в подсказку может привести к высоким затратам, более медленным ответам и достижению пределов «context window» (контекстного окна). В этом сценарии внедрение техник «Retrieval Augmented Generation» (генерации с дополнением извлечёнными данными), или RAG, может повысить производительность и эффективность.

Вы можете создать более масштабируемую и отзывчивую систему, преобразуя информацию в векторные представления с помощью [моделей эмбеддингов](https://platform.claude.com/docs/ru/build-with-claude/embeddings), например моделей от Voyage AI by MongoDB. Этот подход позволяет динамически извлекать релевантную информацию на основе текущего запроса вместо включения всего возможного контекста в каждую подсказку.

Показано, что внедрение RAG в сценариях поддержки повышает точность, сокращает время ответа и снижает затраты на API в системах с обширными требованиями к контексту. Рабочий пример см. в [рецепте RAG](https://platform.claude.com/cookbook/capabilities-retrieval-augmented-generation-guide).

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

При работе с запросами, требующими информации в реальном времени, например остатков на счетах или деталей полиса, подходов RAG на основе эмбеддингов недостаточно. Вместо этого использование инструментов может расширить способность вашего чат-бота давать точные ответы в реальном времени. Например, с помощью использования инструментов можно искать информацию о клиенте, получать детали заказов и отменять заказы от имени клиента.

Этот подход, описанный в [рецепте «использование инструментов: агент службы поддержки клиентов»](https://platform.claude.com/cookbook/tool-use-customer-service-agent), позволяет интегрировать актуальные данные в ответы Claude и обеспечить более персонализированный и эффективный клиентский опыт.

#### Усильте защитные ограничения на входе и выходе

При развёртывании чат-бота, особенно в сценариях обслуживания клиентов, важно предотвращать риски, связанные с злоупотреблениями, запросами вне области применения и неуместными ответами. Хотя Claude изначально устойчив к таким сценариям, вот дополнительные шаги для усиления ограничений вашего чат-бота:

* [Снижение галлюцинаций](https://platform.claude.com/docs/ru/test-and-evaluate/strengthen-guardrails/reduce-hallucinations): внедрите механизмы проверки фактов и [цитирование](https://platform.claude.com/cookbook/misc-using-citations), чтобы ответы опирались на предоставленную информацию.
* Перекрёстная проверка информации: убедитесь, что ответы агента соответствуют политикам вашей компании и известным фактам.
* Избегание договорных обязательств: убедитесь, что агент не даёт обещаний и не заключает соглашений, на которые он не уполномочен.
* [Противодействуйте джейлбрейкам](https://platform.claude.com/docs/ru/test-and-evaluate/strengthen-guardrails/mitigate-jailbreaks): используйте такие методы, как проверки на безвредность и валидация ввода, чтобы не позволить пользователям эксплуатировать уязвимости модели для генерации неуместного контента.
* Избегание упоминания конкурентов: внедрите фильтр упоминаний конкурентов, чтобы сохранять фокус на бренде и не упоминать продукты или услуги конкурентов.
* [Повышение согласованности вывода](https://platform.claude.com/docs/ru/test-and-evaluate/strengthen-guardrails/increase-consistency): не позволяйте Claude менять стиль или выходить из роли даже во время длинных и сложных взаимодействий.
* Удаляйте персональные данные (PII): если это явно не требуется и не разрешено, удаляйте любые PII из ответов.

#### Сократите воспринимаемое время ответа с помощью потоковой передачи

При работе с потенциально длинными ответами внедрение «streaming» (потоковой передачи) может повысить вовлечённость и удовлетворённость пользователей. В этом сценарии пользователи получают ответ постепенно, а не ждут, пока будет сгенерирован весь ответ.

Вот как реализовать потоковую передачу:

1. Используйте [API потоковой передачи Anthropic](https://platform.claude.com/docs/ru/build-with-claude/streaming) для поддержки потоковых ответов.
2. Настройте фронтенд для обработки входящих фрагментов текста.
3. Отображайте каждый фрагмент по мере поступления, имитируя набор текста в реальном времени.
4. Реализуйте механизм сохранения полного ответа, позволяющий пользователям просмотреть его, если они уйдут со страницы и вернутся.

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

#### Масштабируйте ваш чат-бот

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

* Убедитесь, что вы извлекаете максимум из ваших подсказок и оптимизируете их с помощью инженерии подсказок. Используйте [руководства по инженерии подсказок](https://platform.claude.com/docs/ru/build-with-claude/prompt-engineering/overview), чтобы писать наиболее эффективные подсказки.
* Добавьте в подсказку дополнительные [инструменты](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/overview) (которые могут включать [цепочки подсказок](https://platform.claude.com/docs/ru/build-with-claude/prompt-engineering/claude-prompting-best-practices#chain-complex-prompts)) и проверьте, удаётся ли достичь требуемой функциональности.

Если ваш чат-бот обрабатывает чрезвычайно разнообразные задачи, возможно, стоит рассмотреть добавление [отдельного классификатора намерений](https://platform.claude.com/cookbook/capabilities-classification-guide) для маршрутизации первоначального запроса клиента. Для существующего приложения это потребует создания дерева решений, которое будет направлять запросы клиентов через классификатор, а затем в специализированные беседы (со своим набором инструментов и системных подсказок). Обратите внимание, что этот метод требует дополнительного вызова Claude, что может увеличить задержку.

### Интегрируйте Claude в ваш рабочий процесс поддержки

Хотя эти примеры были сосредоточены на функциях Python, вызываемых в среде Streamlit, развёртывание Claude для чат-бота поддержки в реальном времени требует API-сервиса.

Вот как можно к этому подойти:

1. Создайте API-обёртку: разработайте простую API-обёртку вокруг вашей функции классификации. Например, вы можете использовать Flask или FastAPI, чтобы обернуть код в HTTP-сервис. Ваш HTTP-сервис может принимать пользовательский ввод и возвращать ответ Assistant целиком. Таким образом, ваш сервис может обладать следующими характеристиками:

   * Server-Sent Events (SSE): SSE обеспечивает потоковую передачу ответов от сервера клиенту в реальном времени. Это даёт плавный, интерактивный опыт при работе с LLM.
   * Кэширование: внедрение кэширования может улучшить время ответа и сократить ненужные вызовы API.
   * Сохранение контекста: поддержание контекста, когда пользователь уходит и возвращается, важно для непрерывности бесед.

2. Создайте веб-интерфейс: реализуйте удобный веб-интерфейс для взаимодействия с агентом на базе Claude.

## Следующие шаги

<CardGroup cols={2}>
  <Card title="Использование инструментов" icon="wrench" href="https://platform.claude.com/docs/ru/agents-and-tools/tool-use/overview">
    Предоставьте Claude доступ к вашим API, чтобы он мог выполнять действия от имени клиентов.
  </Card>

  <Card title="Разработка тестов" icon="check" href="https://platform.claude.com/docs/ru/test-and-evaluate/develop-tests">
    Создайте оценки, чтобы измерить работу вашего агента поддержки по определённым вами критериям успеха.
  </Card>

  <Card title="Потоковая передача" icon="bolt" href="https://platform.claude.com/docs/ru/build-with-claude/streaming">
    Передавайте ответы потоком, чтобы клиенты видели их по мере генерации.
  </Card>

  <Card title="Инженерия подсказок" icon="lightbulb" href="https://platform.claude.com/docs/ru/build-with-claude/prompt-engineering/overview">
    Доработайте вашу системную подсказку и примеры для лучшего выполнения задач.
  </Card>
</CardGroup>
