Автоматизация онлайн-конференций: как AI берёт на себя рутину

from anthropic import Anthropic
from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import Chroma
from datetime import datetime, timedelta
import json
import asyncio

client = Anthropic()
emveddings = OpenAIEmbeddings(model="text-embedding-3-small")

class EventKnowledgeBase:
    """База знаний о мероприятии для AI-ассистента"""
    def __init__(self, event_id: str):
        self.vectorstore = Chroma(
            collection_name=f"event_{event_id}",
            embedding_function=embeddings,
        )

    def index_event_data(self, event_data: dict):
        """Индексирует данные о мероприятии"""
        texts = []
        metadatas = []

        # Программа
        for session in event_data.get("sessions", []):
            text = f"""Секция: {session['title']}
Спикер: {session['speaker']} ({session['speaker_bio']})
Время: {session['start_time']} — {session['end_time']}
Описание: {session['description']}
Зал/трек: {session.get('track', 'общий')}"""
            texts.append(text)
            metadatas.append({"type": "session", "session_id": session["id"]})

        # FAQ
        for item in event_data.get("faq", []):
            texts.append(f"Вопрос: {item['q']}\nОтвет: {item['a']}")
            metadatas.append({"type": "faq"})

        # Спикеры
        for speaker in event_data.get("speakers", []):
            text = f"""Спикер: {speaker['name']}
Должность: {speaker['title']} в {speaker['company']}
Биография: {speaker['bio']}
Темы: {', '.join(speaker.get('topics', []))}"""
            texts.append(text)
            metadatas.append({"type": "speaker", "speaker_name": speaker["name"]})

        self.vectorstore.add_texts(texts=texts, metadatas=metadatas)

class EventAssistant:
    """AI-ассистент для участников мероприятия"""
    def __init__(self, event_id: str, event_name: str):
        self.event_name = event_name
        self.kb = EventKnowledgeBase(event_id)
        self.sessions: dict[str, list] = {}  # история диалогов

    def answer(self, participant_id: str, question: str, current_time: datetime = None) -> str:
        results = self.kb.vectorstore.similarity_search_with_score(question, k=5)
        context = "\n\n".join([doc.page_content for doc, score in results if (1 - score) > 0.5])
        time_context = f"Текущее время: {current_time.strftime('%H:%M')}" if current_time else ""
        history = self.sessions.get(participant_id, [])
        messages = history + [{
            "role": "user",
            "content": f"{time_context}\n\nВопрос участника: {question}\n\nИнформация о мероприятии:\n{context}"
        }]
        response = client.messages.create(
            model="claude-haiku-4-5",
            max_tokens=512,
            system=f"""Ты — ассистент участников мероприятия «{self.event_name}». Отвечай кратко и конкретно. Если информации нет — скажи честно.""",
            messages=messages,
        )
        answer = response.content[0].text
        history.append({"role": "user", "content": question})
        history.append({"role": "assistant", "content": answer})
        self.sessions[participant_id] = history[-10:]
        return answer

class QAModerator:
    """AI-модерация вопросов Q&A сессии"""
    def __init__(self):
        self.question_queue: list[dict] = []
        self.answered: list[dict] = []

    def moderate_question(self, question: str, participant: dict) -> dict:
        """Модерирует вопрос: релевантность, дубликаты, качество"""
        # Проверяем на дубликат
        if self.question_queue or self.answered:
            existing = [q["question"] for q in self.question_queue + self.answered[-20:]]
            existing_text = "\n".join(f"- {q}" for q in existing[-15:])
        else:
            existing_text = "нет"
        response = client.messages.create(
            model="claude-haiku-4-5",
            max_tokens=256,
            messages=[{
                "role": "user",
                "content": f"""Оцени вопрос для Q&A сессии:
Вопрос: "{question}"
Уже есть вопросы: {existing_text}
Верни JSON: {{
    "approve": true/false,
    "is_duplicate": true/false,
    "duplicate_of": "похожий вопрос или null",
    "quality_score": 1-5,
    "category": "technical|business|personal|off_topic",
    "cleaned_question": "отредактированная версия (убрать грубость, опечатки)",
    "reject_reason": "причина отклонения или null"
}}
Одобряй вопросы по теме, не спам и не грубость. Только JSON."""
            }],
        )
        text = response.content[0].text
        result = json.loads(text[text.find("{"):text.rfind("}") + 1])
        if result.get("approve"):
            self.question_queue.append({
                "question": result.get("cleaned_question", question),
                "original": question,
                "participant": participant,
                "quality": result.get("quality_score", 3),
                "category": result.get("category"),
                "submitted_at": datetime.now().isoformat(),
            })
        return result

    def get_top_questions(self, n: int = 5) -> list[dict]:
        """Возвращает топ вопросов по оценке качества"""
        sorted_queue = sorted(
            self.question_queue,
            key=lambda q: q.get("quality", 3),
            reverse=True
        )
        return sorted_queue[:n]

    def get_summary_for_speaker(self, session_topic: str) -> str:
        """Готовит спикеру сводку вопросов перед Q&A"""
        if not self.question_queue:
            return "Вопросов пока нет."
        questions_text = "\n".join([
            f"{i+1}. [{q['category']}] {q['question']}"
            for i, q in enumerate(self.get_top_questions(10))
        ])
        response = client.messages.create(
            model="claude-haiku-4-5",
            max_tokens=512,
            messages=[{
                "role": "user",
                "content": f"""Тема сессии: {session_topic}
Вопросы от аудитории: {questions_text}
Сгруппируй по темам, выдели наиболее частые — помоги спикеру подготовиться к Q&A. Кратко, по делу."""
            }],
        )
        return response.content[0].text