Интеграция с OpenAI API: полное руководство по AI-автоматизации

 1import openai
 2from typing import Optional
 3
 4class OpenAIClient:
 5    """Клиент для работы с OpenAI API"""
 6    
 7    def __init__(self, api_key: str, model: str = "gpt-4o-mini"):
 8        self.client = openai.AsyncOpenAI(api_key=api_key)
 9        self.model = model
10    
11    async def chat(
12        self,
13        messages: list[dict],
14        system_prompt: str = "",
15        temperature: float = 0.7,
16        max_tokens: int = 2000,
17        json_mode: bool = False,
18    ) -> str:
19        """Отправить запрос к ChatGPT"""
20        full_messages = []
21        if system_prompt:
22            full_messages.append({"role": "system", "content": system_prompt})
23        full_messages.extend(messages)
24        
25        kwargs = {
26            "model": self.model,
27            "messages": full_messages,
28            "temperature": temperature,
29            "max_tokens": max_tokens,
30        }
31        if json_mode:
32            kwargs["response_format"] = {"type": "json_object"}
33        
34        response = await self.client.chat.completions.create(**kwargs)
35        return response.choices[0].message.content
36    
37    async def generate_image(
38        self,
39        prompt: str,
40        size: str = "1024x1024",
41        quality: str = "standard",
42    ) -> str:
43        """Сгенерировать изображение через DALL-E 3"""
44        response = await self.client.images.generate(
45            model="dall-e-3",
46            prompt=prompt,
47            size=size,
48            quality=quality,
49            n=1,
50        )
51        return response.data[0].url
52    
53    async def transcribe(self, audio_path: str, language: str = "ru") -> str:
54        """Транскрибировать аудио через Whisper"""
55        with open(audio_path, "rb") as audio_file:
56            response = await self.client.audio.transcriptions.create(
57                model="whisper-1",
58                file=audio_file,
59                language=language,
60            )
61        return response.text
62    
63    async def text_to_speech(
64        self,
65        text: str,
66        voice: str = "nova",
67        speed: float = 1.0,
68    ) -> bytes:
69        """Преобразовать текст в речь"""
70        response = await self.client.audio.speech.create(
71            model="tts-1-hd",
72            voice=voice,
73            input=text,
74            speed=speed,
75        )
76        return response.content

 1import json
 2
 3# Описание функций для GPT
 4TOOLS = [
 5    {
 6        "type": "function",
 7        "function": {
 8            "name": "search_products",
 9            "description": "Поиск товаров в каталоге по запросу, категории или цене",
10            "parameters": {
11                "type": "object",
12                "properties": {
13                    "query": {"type": "string", "description": "Поисковый запрос"},
14                    "category": {"type": "string", "description": "Категория товаров"},
15                    "min_price": {"type": "number", "description": "Минимальная цена"},
16                    "max_price": {"type": "number", "description": "Максимальная цена"},
17                },
18                "required": ["query"],
19            },
20        },
21    },
22    {
23        "type": "function",
24        "function": {
25            "name": "get_order_status",
26            "description": "Получить статус заказа по номеру",
27            "parameters": {
28                "type": "object",
29                "properties": {
30                    "order_id": {"type": "string", "description": "Номер заказа"},
31                },
32                "required": ["order_id"],
33            },
34        },
35    },
36    {
37        "type": "function",
38        "function": {
39            "name": "create_support_ticket",
40            "description": "Создать тикет в службу поддержки",
41            "parameters": {
42                "type": "object",
43                "properties": {
44                    "subject": {"type": "string", "description": "Тема обращения"},
45                    "description": {"type": "string", "description": "Описание проблемы"},
46                    "priority": {"type": "string", "enum": ["low", "medium", "high"]},
47                },
48                "required": ["subject", "description"],
49            },
50        },
51    },
52]
53
54# Реализация функций
55async def search_products(query: str, category: str = None, 
56                          min_price: float = None, max_price: float = None) -> list:
57    """Поиск товаров в базе данных"""
58    # Здесь реальный запрос к БД
59    return [
60        {"name": "Кроссовки Nike Air Max", "price": 8990, "in_stock": True},
61        {"name": "Кроссовки Adidas Ultraboost", "price": 12490, "in_stock": True},
62    ]
63
64async def get_order_status(order_id: str) -> dict:
65    """Получить статус заказа"""
66    return {"order_id": order_id, "status": "В доставке", "eta": "2 дня"}
67
68async def create_support_ticket(subject: str, description: str, priority: str) -> dict:
69    """Создать тикет поддержки"""
70    return {"ticket_id": "T-12345", "status": "created"}
71
72# Маппинг функций
73FUNCTION_MAP = {
74    "search_products": search_products,
75    "get_order_status": get_order_status,
76    "create_support_ticket": create_support_ticket,
77}
78
79async def chat_with_functions(client: OpenAIClient, user_message: str, 
80                              history: list[dict]) -> str:
81    """Чат с Function Calling"""
82    history.append({"role": "user", "content": user_message})
83    
84    response = await client.client.chat.completions.create(
85        model="gpt-4o-mini",
86        messages=[
87            {"role": "system", "content": "Ты помощник интернет-магазина. "
88             "Помогай клиентам с поиском товаров, статусом заказов и поддержкой."},
89            *history,
90        ],
91        tools=TOOLS,
92        tool_choice="auto",
93    )
94    
95    message = response.choices[0].message
96    
97    # Если GPT хочет вызвать функцию
98    if message.tool_calls:
99        history.append(message)
100        
101        for tool_call in message.tool_calls:
102            func_name = tool_call.function.name
103            func_args = json.loads(tool_call.function.arguments)
104            
105            # Выполняем функцию
106            result = await FUNCTION_MAP[func_name](**func_args)
107            
108            # Возвращаем результат GPT
109            history.append({
110                "role": "tool",
111                "tool_call_id": tool_call.id,
112                "content": json.dumps(result, ensure_ascii=False),
113            })
114        
115        # GPT формирует финальный ответ
116        final_response = await client.client.chat.completions.create(
117            model="gpt-4o-mini",
118            messages=[
119                {"role": "system", "content": "Ты помощник интернет-магазина."},
120                *history,
121            ],
122        )
123        answer = final_response.choices[0].message.content
124        history.append({"role": "assistant", "content": answer})
125        return answer
126    
127    # Если GPT отвечает текстом без вызова функций
128    answer = message.content
129    history.append({"role": "assistant", "content": answer})
130    return answer

 1import openai
 2import chromadb
 3from chromadb.utils import embedding_functions
 4
 5class RAGAssistant:
 6    """AI-ассистент с RAG на основе базы знаний"""
 7    
 8    def __init__(self, openai_api_key: str, collection_name: str = "knowledge_base"):
 9        self.client = openai.AsyncOpenAI(api_key=openai_api_key)
10        self.chroma = chromadb.PersistentClient(path="./chroma_db")
11        self.embed_fn = embedding_functions.OpenAIEmbeddingFunction(
12            api_key=openai_api_key, model_name="text-embedding-3-small"
13        )
14        self.collection = self.chroma.get_or_create_collection(
15            name=collection_name, embedding_function=self.embed_fn
16        )
17    
18    async def add_documents(self, documents: list[dict]):
19        """Добавить документы в базу знаний"""
20        for i, doc in enumerate(documents):
21            # Разбиваем на чанки по 500 токенов
22            chunks = self._split_text(doc["text"], max_tokens=500)
23            for j, chunk in enumerate(chunks):
24                self.collection.add(
25                    documents=[chunk],
26                    ids=[f"{doc['id']}_{j}"],
27                    metadatas=[{
28                        "source": doc.get("source", ""),
29                        "title": doc.get("title", ""),
30                        "chunk_index": j,
31                    }],
32                )
33    
34    async def query(self, question: str, top_k: int = 5) -> str:
35        """Задать вопрос на основе базы знаний"""
36        # 1. Семантический поиск релевантных чанков
37        results = self.collection.query(query_texts=[question], n_results=top_k)
38        
39        context = "\n\n".join([
40            f"[Источник: {m.get('source', 'Неизвестен')}]\n{doc}"
41            for doc, m in zip(results["documents"][0], results["metadatas"][0])
42        ])
43        
44        # 2. Генерация ответа на основе контекста
45        response = await self.client.chat.completions.create(
46            model="gpt-4o-mini",
47            messages=[
48                {"role": "system", "content": "Ты помощник компании. Отвечай ТОЛЬКО на основе "
49                 "предоставленного контекста. Если информации недостаточно — скажи об этом.\n\n"
50                 f"КОНТЕКСТ:\n{context}"},
51                {"role": "user", "content": question},
52            ],
53            temperature=0.3,
54        )
55        
56        return response.choices[0].message.content
57    
58    def _split_text(self, text: str, max_tokens: int = 500) -> list[str]:
59        """Разбить текст на чанки"""
60        words = text.split()
61        chunks = []
62        current = []
63        for word in words:
64            current.append(word)
65            if len(current) >= max_tokens:
66                chunks.append(" ".join(current))
67                current = []
68        if current:
69            chunks.append(" ".join(current))
70        return chunks

 1Клиент: Как мне изменить тарифный план?
 2
 3AI-ассистент: Чтобы изменить тарифный план:
 41. Зайдите в «Настройки» → «Подписка»
 52. Нажмите «Изменить тариф»
 63. Выберите новый тариф и подтвердите
 7
 8Изменение вступит в силу сразу. Если вы перейдёте на более дорогой тариф, 
 9разница будет пересчитана пропорционально оставшимся дням.
10
11Нужна помощь с выбором тарифа? Я могу подобрать оптимальный вариант под ваши задачи.
12
13Клиент: Да, мне нужно больше места для файлов.
14
15AI-ассистент: Исходя из вашего использования (12 ГБ из 15 ГБ), рекомендую 
16тариф «Бизнес» — 100 ГБ хранилища за 990 ₽/мес. Это в 3 раза дешевле, 
17если сравнивать с расширением текущего тарифа.
18
19Хотите, чтобы я оформил переход?