Upload folder using huggingface_hub

Dockerfile

@@ -0,0 +1,26 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install system dependencies (ffmpeg REQUIRED for audio conversion!)
+RUN apt-get update && apt-get install -y \
+    ffmpeg \
+    libsndfile1 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Force rebuild: v1 (change this comment to invalidate Docker cache)
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Pre-download Whisper model during build (faster startup)
+RUN python -c "from transformers import pipeline; pipeline('automatic-speech-recognition', model='openai/whisper-small')"
+
+# Copy application code
+COPY ./app /app/app
+
+# HuggingFace Spaces uses port 7860
+EXPOSE 7860
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,10 +1,32 @@
 ---
-title: Checklist Agent
-emoji: 🦀
-colorFrom: indigo
-colorTo: red
+title: AI Checklist Agent
+emoji: 📋
+colorFrom: blue
+colorTo: green
 sdk: docker
 pinned: false
+license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# AI Checklist Agent Backend
+
+API сервис для AI агента заполнения чеклиста созвона с клиентом.
+
+## Features
+
+- Голосовой ввод с транскрипцией через Whisper
+- 3 раунда по 3 вопроса (адаптивные)
+- Генерация структурированного чеклиста
+- Экспорт в Markdown
+
+## API Endpoints
+
+- `POST /api/session/start` - Начать новую сессию
+- `POST /api/session/transcribe` - Транскрибировать аудио
+- `POST /api/session/{id}/submit` - Отправить ответы
+- `GET /api/session/{id}/results` - Получить результаты
+- `GET /api/session/{id}/download` - Скачать MD файл
+
+## Environment Variables
+
+- `ANTHROPIC_API_KEY` - API ключ Anthropic для Claude

app/agent/graph.py

@@ -0,0 +1,51 @@
+from langgraph.graph import StateGraph, END
+from app.agent.state import AgentState
+from app.agent.nodes import (
+    generate_initial_questions,
+    process_answers,
+    analyze_round,
+    generate_checklist,
+    check_round_complete
+)
+
+
+def create_checklist_agent() -> StateGraph:
+    """Создает LangGraph для чеклист-агента"""
+    
+    # Создаем граф с состоянием AgentState
+    workflow = StateGraph(AgentState)
+    
+    # Добавляем ноды
+    workflow.add_node("generate_initial_questions", generate_initial_questions)
+    workflow.add_node("process_answers", process_answers)
+    workflow.add_node("analyze_round", analyze_round)
+    workflow.add_node("generate_checklist", generate_checklist)
+    
+    # Устанавливаем начальную точку
+    workflow.set_entry_point("generate_initial_questions")
+    
+    # Добавляем переходы
+    # После генерации вопросов - ждем ответы (END чтобы вернуть контроль)
+    workflow.add_edge("generate_initial_questions", END)
+    
+    # После обработки ответов - анализируем раунд
+    workflow.add_edge("process_answers", "analyze_round")
+    
+    # После анализа - либо ждем новые ответы, либо генерируем чеклист
+    workflow.add_conditional_edges(
+        "analyze_round",
+        check_round_complete,
+        {
+            "wait_for_answers": END,  # Ждем следующие ответы
+            "generate_checklist": "generate_checklist"  # Генерируем чеклист
+        }
+    )
+    
+    # После генерации чеклиста - конец
+    workflow.add_edge("generate_checklist", END)
+    
+    return workflow.compile()
+
+
+# Создаем экземпляр агента
+checklist_agent = create_checklist_agent()

app/agent/nodes.py

@@ -0,0 +1,132 @@
+from typing import Dict, Any
+from app.agent.state import AgentState
+from app.services.llm import get_llm_service
+from app.services.file_generator import get_file_generator
+from app.models.question import Question, Answer
+from app.models.checklist import ChecklistItem
+
+
+def generate_initial_questions(state: AgentState) -> Dict[str, Any]:
+    """Генерирует первые 3 вопроса для начала интервью"""
+    llm = get_llm_service()
+    questions_data = llm.generate_initial_questions()
+    
+    questions = [
+        Question(id=q["id"], text=q["text"])
+        for q in questions_data
+    ]
+    
+    return {
+        "current_questions": questions,
+        "current_round": 1,
+        "waiting_for_answers": True
+    }
+
+
+def process_answers(state: AgentState) -> Dict[str, Any]:
+    """Обрабатывает полученные ответы и создает Answer объекты"""
+    transcripts = state.get("pending_transcripts", [])
+    current_questions = state.get("current_questions", [])
+    current_round = state.get("current_round", 1)
+    all_answers = list(state.get("all_answers", []))
+    
+    # Создаем Answer объекты из транскриптов
+    for i, transcript in enumerate(transcripts):
+        if i < len(current_questions):
+            answer = Answer(
+                question_id=current_questions[i].id,
+                question_text=current_questions[i].text,
+                audio_transcript=transcript,
+                round_number=current_round
+            )
+            all_answers.append(answer)
+    
+    return {
+        "all_answers": all_answers,
+        "pending_transcripts": [],
+        "waiting_for_answers": False
+    }
+
+
+def analyze_round(state: AgentState) -> Dict[str, Any]:
+    """Анализирует ответы раунда и генерирует следующие вопросы или завершает"""
+    llm = get_llm_service()
+    
+    current_round = state.get("current_round", 1)
+    all_answers = state.get("all_answers", [])
+    round_summaries = list(state.get("round_summaries", []))
+    
+    # Анализируем раунд
+    result = llm.analyze_round_and_generate_questions(
+        round_number=current_round,
+        all_answers=all_answers,
+        round_summaries=round_summaries
+    )
+    
+    # Добавляем саммари раунда
+    round_summaries.append(result.get("round_summary", ""))
+    
+    # Если это не последний раунд - генерируем следующие вопросы
+    if current_round < state.get("max_rounds", 3):
+        questions_data = result.get("questions", [])
+        questions = [
+            Question(id=q["id"], text=q["text"])
+            for q in questions_data
+        ]
+        
+        return {
+            "current_questions": questions,
+            "current_round": current_round + 1,
+            "round_summaries": round_summaries,
+            "waiting_for_answers": True,
+            "is_complete": False
+        }
+    else:
+        # Последний раунд - готовимся к генерации чеклиста
+        return {
+            "round_summaries": round_summaries,
+            "waiting_for_answers": False,
+            "is_complete": False
+        }
+
+
+def generate_checklist(state: AgentState) -> Dict[str, Any]:
+    """Генерирует финальный чеклист"""
+    llm = get_llm_service()
+    file_gen = get_file_generator()
+    
+    all_answers = state.get("all_answers", [])
+    round_summaries = state.get("round_summaries", [])
+    session_id = state.get("session_id", "unknown")
+    
+    # Генерируем чеклист
+    result = llm.generate_checklist(all_answers, round_summaries)
+    
+    checklist_items = [
+        ChecklistItem(**item)
+        for item in result.get("checklist", [])
+    ]
+    
+    # Генерируем Markdown
+    markdown = file_gen.generate_markdown(
+        session_id=session_id,
+        checklist=checklist_items,
+        round_summaries=round_summaries
+    )
+    
+    return {
+        "checklist_items": checklist_items,
+        "markdown_content": markdown,
+        "is_complete": True
+    }
+
+
+def check_round_complete(state: AgentState) -> str:
+    """Проверяет, нужно ли продолжать или завершать"""
+    current_round = state.get("current_round", 1)
+    max_rounds = state.get("max_rounds", 3)
+    
+    if current_round >= max_rounds:
+        return "generate_checklist"
+    else:
+        return "wait_for_answers"

app/agent/prompts.py

@@ -0,0 +1,57 @@
+SYSTEM_PROMPT = """Ты - AI ассистент, который помогает заполнить чеклист созвона с клиентом.
+Твоя задача - задавать вопросы и анализировать ответы, чтобы собрать всю необходимую информацию о проекте клиента.
+
+Основные темы для выяснения:
+1. Общая информация о проекте (название, описание, контакты)
+2. Цели и задачи (что хотят достичь, ключевые метрики)
+3. Сроки и бюджет (дедлайны, финансовые ограничения)
+4. Технические требования (интеграции, платформы, технологии)
+5. Дополнительная информация (риски, особенности, пожелания)
+
+Правила:
+- Задавай открытые вопросы
+- Адаптируй следующие вопросы на основе полученных ответов
+- Будь вежливым и профессиональным
+- Все общение ведется на русском языке
+"""
+
+INITIAL_QUESTIONS_PROMPT = """Сгенерируй 3 начальных вопроса для клиента.
+
+Вопросы должны быть направлены на выяснение:
+1. Общей информации о проекте
+2. Целей и ожидаемых результатов
+3. Текущей ситуации и контекста
+
+Формат ответа - JSON:
+{
+    "questions": [
+        {"id": "q1", "text": "..."},
+        {"id": "q2", "text": "..."},
+        {"id": "q3", "text": "..."}
+    ]
+}
+"""
+
+ANALYZE_ROUND_PROMPT = """Проанализируй ответы клиента и:
+1. Создай краткое саммари раунда (2-3 предложения)
+2. Определи, какая информация уже получена
+3. Определи, что еще нужно уточнить
+4. Сгенерируй 3 уточняющих вопроса для следующего раунда
+
+Фокусируйся на недостающей информации и углубляй понимание проекта.
+"""
+
+GENERATE_CHECKLIST_PROMPT = """На основе всех полученных ответов создай структурированный чеклист.
+
+Используй категории:
+- Общая информация
+- Цели и задачи
+- Сроки и бюджет
+- Технические требования
+- Дополнительные заметки
+
+Для каждого пункта укажи статус:
+- confirmed - информация подтверждена
+- needs_clarification - требует уточнения
+- not_discussed - не обсуждалось
+"""

app/agent/state.py

@@ -0,0 +1,28 @@
+from typing import TypedDict, List, Optional
+from app.models.question import Question, Answer
+from app.models.checklist import ChecklistItem
+
+
+class AgentState(TypedDict):
+    # Session info
+    session_id: str
+    
+    # Round tracking
+    current_round: int  # 1, 2, or 3
+    max_rounds: int     # 3
+    
+    # Questions & Answers
+    current_questions: List[Question]
+    all_answers: List[Answer]
+    pending_transcripts: List[str]
+    
+    # Analysis
+    round_summaries: List[str]
+    
+    # Final output
+    checklist_items: List[ChecklistItem]
+    markdown_content: str
+    
+    # Control flow
+    is_complete: bool
+    waiting_for_answers: bool

app/config.py

@@ -0,0 +1,19 @@
+from pydantic_settings import BaseSettings
+from functools import lru_cache
+
+
+class Settings(BaseSettings):
+    anthropic_api_key: str = ""
+    environment: str = "development"
+    max_audio_duration_seconds: int = 120
+    whisper_model: str = "openai/whisper-small"
+    allowed_origins: str = "*"
+
+    class Config:
+        env_file = ".env"
+        extra = "ignore"
+
+
+@lru_cache()
+def get_settings() -> Settings:
+    return Settings()

app/main.py

@@ -0,0 +1,52 @@
+from contextlib import asynccontextmanager
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from app.config import get_settings
+from app.routers import health, session
+from app.services.transcription import get_transcription_service
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # Загружаем Whisper модель при старте
+    print("Загрузка Whisper модели...")
+    service = get_transcription_service()
+    service._get_pipeline()
+    print("Whisper модель загружена!")
+    yield
+    # Cleanup при остановке
+    print("Остановка сервиса...")
+
+
+app = FastAPI(
+    title="AI Checklist Agent API",
+    description="API для AI агента заполнения чеклиста созвона с клиентом",
+    version="1.0.0",
+    lifespan=lifespan
+)
+
+# Настройка CORS
+settings = get_settings()
+origins = settings.allowed_origins.split(",") if settings.allowed_origins != "*" else ["*"]
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=origins,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Подключаем роутеры
+app.include_router(health.router)
+app.include_router(session.router)
+
+
+@app.get("/")
+async def root():
+    return {
+        "message": "AI Checklist Agent API",
+        "docs": "/docs",
+        "health": "/health"
+    }

app/models/checklist.py

@@ -0,0 +1,15 @@
+from pydantic import BaseModel
+from typing import Optional, List
+
+
+class ChecklistItem(BaseModel):
+    category: str
+    item: str
+    status: str  # "confirmed" | "needs_clarification" | "not_discussed"
+    notes: Optional[str] = None
+
+
+class ChecklistResponse(BaseModel):
+    session_id: str
+    checklist: List[ChecklistItem]
+    markdown: str

app/models/question.py

@@ -0,0 +1,19 @@
+from pydantic import BaseModel
+from typing import Optional
+
+
+class Question(BaseModel):
+    id: str
+    text: str
+
+
+class Answer(BaseModel):
+    question_id: str
+    question_text: str
+    audio_transcript: str
+    round_number: int
+
+
+class QuestionResponse(BaseModel):
+    id: str
+    text: str

app/models/session.py

@@ -0,0 +1,29 @@
+from pydantic import BaseModel
+from typing import List, Optional
+from .question import Question, Answer
+from .checklist import ChecklistItem
+
+
+class SessionStartResponse(BaseModel):
+    session_id: str
+    round: int
+    questions: List[Question]
+
+
+class TranscribeResponse(BaseModel):
+    transcript: str
+
+
+class SubmitResponse(BaseModel):
+    round: int
+    is_complete: bool
+    questions: Optional[List[Question]] = None
+    round_summary: Optional[str] = None
+    checklist_preview: Optional[str] = None
+    transcripts: Optional[List[str]] = None
+
+
+class SessionResultsResponse(BaseModel):
+    session_id: str
+    checklist: List[ChecklistItem]
+    markdown: str

app/routers/health.py

@@ -0,0 +1,12 @@
+from fastapi import APIRouter
+
+router = APIRouter(tags=["health"])
+
+
+@router.get("/health")
+async def health_check():
+    """Health check для HuggingFace Spaces"""
+    return {
+        "status": "healthy",
+        "service": "checklist-agent"
+    }

app/routers/session.py

@@ -0,0 +1,173 @@
+from fastapi import APIRouter, UploadFile, File, Form, HTTPException
+from fastapi.responses import Response
+from typing import Annotated, List
+import uuid
+
+from app.models.session import (
+    SessionStartResponse,
+    TranscribeResponse,
+    SubmitResponse,
+    SessionResultsResponse
+)
+from app.models.question import Question
+from app.services.transcription import get_transcription_service
+from app.agent.graph import checklist_agent
+from app.agent.state import AgentState
+
+router = APIRouter(prefix="/api/session", tags=["session"])
+
+# In-memory хранилище сессий (для MVP)
+sessions: dict[str, AgentState] = {}
+
+
+@router.post("/start", response_model=SessionStartResponse)
+async def start_session():
+    """Создает новую сессию и возвращает первые 3 вопроса"""
+    session_id = str(uuid.uuid4())[:8]
+    
+    # Инициализируем состояние агента
+    initial_state: AgentState = {
+        "session_id": session_id,
+        "current_round": 0,
+        "max_rounds": 3,
+        "current_questions": [],
+        "all_answers": [],
+        "pending_transcripts": [],
+        "round_summaries": [],
+        "checklist_items": [],
+        "markdown_content": "",
+        "is_complete": False,
+        "waiting_for_answers": False
+    }
+    
+    # Запускаем агент для генерации первых вопросов
+    result = checklist_agent.invoke(initial_state)
+    
+    # Сохраняем состояние
+    sessions[session_id] = result
+    
+    return SessionStartResponse(
+        session_id=session_id,
+        round=result["current_round"],
+        questions=result["current_questions"]
+    )
+
+
+@router.post("/transcribe", response_model=TranscribeResponse)
+async def transcribe_audio(
+    audio_file: Annotated[UploadFile, File(description="Audio file in webm format")]
+):
+    """Транскрибирует одно аудио и возвращает текст (для превью)"""
+    transcription_service = get_transcription_service()
+    
+    audio_bytes = await audio_file.read()
+    transcript = await transcription_service.transcribe(audio_bytes)
+    
+    return TranscribeResponse(transcript=transcript)
+
+
+@router.post("/{session_id}/submit", response_model=SubmitResponse)
+async def submit_answers(
+    session_id: str,
+    audio_files: Annotated[List[UploadFile], File(description="Audio files in webm format")],
+    question_ids: Annotated[str, Form(description="Comma-separated question IDs")]
+):
+    """Отправляет аудио-ответы и получает следующие вопросы или результат"""
+    if session_id not in sessions:
+        raise HTTPException(status_code=404, detail="Сессия не найдена")
+    
+    state = sessions[session_id]
+    transcription_service = get_transcription_service()
+    
+    # Транскрибируем все аудио
+    transcripts = []
+    for audio_file in audio_files:
+        audio_bytes = await audio_file.read()
+        transcript = await transcription_service.transcribe(audio_bytes)
+        transcripts.append(transcript)
+    
+    # Обновляем состояние с транскриптами
+    state["pending_transcripts"] = transcripts
+    state["waiting_for_answers"] = False
+    
+    # Запускаем обработку ответов
+    from app.agent.nodes import process_answers, analyze_round, generate_checklist, check_round_complete
+    
+    # Обрабатываем ответы
+    updates = process_answers(state)
+    for key, value in updates.items():
+        state[key] = value
+    
+    # Анализируем раунд
+    updates = analyze_round(state)
+    for key, value in updates.items():
+        state[key] = value
+    
+    # Проверяем, нужно ли генерировать чеклист
+    current_round = state.get("current_round", 1)
+    if current_round > state.get("max_rounds", 3) or state.get("is_complete", False):
+        # Генерируем чеклист
+        updates = generate_checklist(state)
+        for key, value in updates.items():
+            state[key] = value
+    
+    # Сохраняем обновленное состояние
+    sessions[session_id] = state
+    
+    # Формируем ответ
+    if state.get("is_complete", False):
+        return SubmitResponse(
+            round=state["current_round"],
+            is_complete=True,
+            checklist_preview=state.get("markdown_content", ""),
+            round_summary=state["round_summaries"][-1] if state["round_summaries"] else None,
+            transcripts=transcripts
+        )
+    else:
+        return SubmitResponse(
+            round=state["current_round"],
+            is_complete=False,
+            questions=state.get("current_questions", []),
+            round_summary=state["round_summaries"][-1] if state["round_summaries"] else None,
+            transcripts=transcripts
+        )
+
+
+@router.get("/{session_id}/results", response_model=SessionResultsResponse)
+async def get_results(session_id: str):
+    """Получает финальный чеклист"""
+    if session_id not in sessions:
+        raise HTTPException(status_code=404, detail="Сессия не найдена")
+    
+    state = sessions[session_id]
+    
+    if not state.get("is_complete", False):
+        raise HTTPException(status_code=400, detail="Сессия еще не завершена")
+    
+    return SessionResultsResponse(
+        session_id=session_id,
+        checklist=state.get("checklist_items", []),
+        markdown=state.get("markdown_content", "")
+    )
+
+
+@router.get("/{session_id}/download")
+async def download_checklist(session_id: str):
+    """Скачивает MD файл с чеклистом"""
+    if session_id not in sessions:
+        raise HTTPException(status_code=404, detail="Сессия не найдена")
+    
+    state = sessions[session_id]
+    
+    if not state.get("is_complete", False):
+        raise HTTPException(status_code=400, detail="Сессия еще не завершена")
+    
+    markdown = state.get("markdown_content", "")
+    
+    return Response(
+        content=markdown.encode("utf-8"),
+        media_type="text/markdown",
+        headers={
+            "Content-Disposition": f'attachment; filename="checklist-{session_id}.md"'
+        }
+    )

app/services/file_generator.py

@@ -0,0 +1,64 @@
+from typing import List
+from datetime import datetime
+from app.models.checklist import ChecklistItem
+
+
+class FileGenerator:
+    @staticmethod
+    def generate_markdown(
+        session_id: str,
+        checklist: List[ChecklistItem],
+        round_summaries: List[str]
+    ) -> str:
+        """Генерирует Markdown файл с результатами чеклиста"""
+        
+        date = datetime.now().strftime("%Y-%m-%d %H:%M")
+        
+        md_content = f"""# Чеклист созвона с клиентом
+
+**Дата:** {date}
+**Сессия:** {session_id}
+
+---
+
+"""
+        # Группируем по категориям
+        categories = {}
+        for item in checklist:
+            if item.category not in categories:
+                categories[item.category] = []
+            categories[item.category].append(item)
+
+        # Маппинг статусов на чекбоксы
+        status_map = {
+            "confirmed": "[x]",
+            "needs_clarification": "[ ] ⚠️",
+            "not_discussed": "[ ]"
+        }
+
+        for category, items in categories.items():
+            md_content += f"## {category}\n\n"
+            for item in items:
+                checkbox = status_map.get(item.status, "[ ]")
+                line = f"- {checkbox} {item.item}"
+                if item.notes:
+                    line += f" *({item.notes})*"
+                md_content += line + "\n"
+            md_content += "\n"
+
+        # Добавляем саммари раундов
+        if round_summaries:
+            md_content += "---\n\n## Саммари интервью\n\n"
+            for i, summary in enumerate(round_summaries, 1):
+                md_content += f"**Раунд {i}:** {summary}\n\n"
+
+        md_content += """---
+
+*Сгенерировано автоматически с помощью AI Checklist Agent*
+"""
+        
+        return md_content
+
+
+def get_file_generator() -> FileGenerator:
+    return FileGenerator()

app/services/llm.py

@@ -0,0 +1,169 @@
+from anthropic import Anthropic
+from typing import List, Dict, Any
+from app.config import get_settings
+from app.models.question import Answer
+from app.models.checklist import ChecklistItem
+import json
+
+
+class LLMService:
+    def __init__(self):
+        settings = get_settings()
+        self.client = Anthropic(api_key=settings.anthropic_api_key)
+        self.model = "claude-sonnet-4-20250514"
+
+    def generate_initial_questions(self) -> List[Dict[str, str]]:
+        """Генерирует первые 3 вопроса для начала интервью"""
+        response = self.client.messages.create(
+            model=self.model,
+            max_tokens=1024,
+            messages=[
+                {
+                    "role": "user",
+                    "content": """Ты - AI ассистент, который помогает заполнить чеклист созвона с клиентом.
+                    
+Сгенерируй 3 начальных вопроса для клиента, чтобы понять суть его проекта.
+Вопросы должны быть открытыми и направлены на выяснение:
+1. Общей информации о проекте
+2. Целей и задач
+3. Текущей ситуации
+
+Ответ верни в формате JSON:
+{
+    "questions": [
+        {"id": "q1", "text": "текст вопроса 1"},
+        {"id": "q2", "text": "текст вопроса 2"},
+        {"id": "q3", "text": "текст вопроса 3"}
+    ]
+}
+
+Только JSON, без дополнительного текста."""
+                }
+            ]
+        )
+        
+        result = json.loads(response.content[0].text)
+        return result["questions"]
+
+    def analyze_round_and_generate_questions(
+        self,
+        round_number: int,
+        all_answers: List[Answer],
+        round_summaries: List[str]
+    ) -> Dict[str, Any]:
+        """Анализирует ответы раунда и генерирует следующие вопросы"""
+        
+        answers_text = "\n".join([
+            f"Вопрос: {a.question_text}\nОтвет: {a.audio_transcript}"
+            for a in all_answers
+        ])
+        
+        summaries_text = "\n".join([
+            f"Раунд {i+1}: {s}" for i, s in enumerate(round_summaries)
+        ]) if round_summaries else "Нет предыдущих саммари"
+
+        response = self.client.messages.create(
+            model=self.model,
+            max_tokens=2048,
+            messages=[
+                {
+                    "role": "user",
+                    "content": f"""Ты - AI ассистент для заполнения чеклиста созвона с клиентом.
+
+Текущий раунд: {round_number}
+Всего раундов: 3
+
+Предыдущие саммари:
+{summaries_text}
+
+Все ответы клиента:
+{answers_text}
+
+Задача:
+1. Создай краткое саммари текущего раунда (2-3 предложения)
+2. Если это не последний раунд (раунд < 3), сгенерируй 3 уточняющих вопроса на основе полученных ответов
+
+Ответ в формате JSON:
+{{
+    "round_summary": "краткое саммари раунда",
+    "questions": [
+        {{"id": "q{round_number*3+1}", "text": "вопрос 1"}},
+        {{"id": "q{round_number*3+2}", "text": "вопрос 2"}},
+        {{"id": "q{round_number*3+3}", "text": "вопрос 3"}}
+    ]
+}}
+
+Если это раунд 3, поле "questions" может быть пустым массивом.
+Только JSON, без дополнительного текста."""
+                }
+            ]
+        )
+        
+        return json.loads(response.content[0].text)
+
+    def generate_checklist(
+        self,
+        all_answers: List[Answer],
+        round_summaries: List[str]
+    ) -> Dict[str, Any]:
+        """Генерирует финальный чеклист на основе всех ответов"""
+        
+        answers_text = "\n".join([
+            f"Вопрос: {a.question_text}\nОтвет: {a.audio_transcript}"
+            for a in all_answers
+        ])
+        
+        summaries_text = "\n".join([
+            f"Раунд {i+1}: {s}" for i, s in enumerate(round_summaries)
+        ])
+
+        response = self.client.messages.create(
+            model=self.model,
+            max_tokens=4096,
+            messages=[
+                {
+                    "role": "user",
+                    "content": f"""Ты - AI ассистент для заполнения чеклиста созвона с клиентом.
+
+Саммари раундов:
+{summaries_text}
+
+Все ответы клиента:
+{answers_text}
+
+Создай структурированный чеклист созвона с клиентом.
+
+Ответ в ��ормате JSON:
+{{
+    "checklist": [
+        {{
+            "category": "Общая информация",
+            "item": "описание пункта",
+            "status": "confirmed",
+            "notes": "дополнительные заметки или null"
+        }}
+    ]
+}}
+
+Статусы:
+- "confirmed" - информация получена и подтверждена
+- "needs_clarification" - требует уточнения
+- "not_discussed" - не обсуждалось
+
+Категории могут быть:
+- Общая информация
+- Цели и задачи
+- Сроки и бюджет
+- Технические требования
+- Дополнительные заметки
+
+Только JSON, без дополнительного текста."""
+                }
+            ]
+        )
+        
+        return json.loads(response.content[0].text)
+
+
+def get_llm_service() -> LLMService:
+    return LLMService()

app/services/transcription.py

@@ -0,0 +1,68 @@
+import subprocess
+import tempfile
+import os
+from functools import lru_cache
+from transformers import pipeline
+from app.config import get_settings
+
+
+class TranscriptionService:
+    def __init__(self):
+        self._pipeline = None
+
+    def _get_pipeline(self):
+        if self._pipeline is None:
+            settings = get_settings()
+            self._pipeline = pipeline(
+                "automatic-speech-recognition",
+                model=settings.whisper_model,
+                device="cpu"
+            )
+        return self._pipeline
+
+    async def transcribe(self, audio_bytes: bytes) -> str:
+        """Транскрибирует аудио используя локальную модель Whisper с конвертацией через ffmpeg"""
+        tmp_webm = None
+        tmp_wav = None
+
+        try:
+            # Сохраняем webm во временный файл
+            with tempfile.NamedTemporaryFile(suffix=".webm", delete=False) as f:
+                f.write(audio_bytes)
+                tmp_webm = f.name
+
+            # Конвертируем webm в wav через ffmpeg
+            tmp_wav = tmp_webm.replace(".webm", ".wav")
+            process = subprocess.run(
+                [
+                    "ffmpeg", "-i", tmp_webm,
+                    "-ar", "16000",  # 16kHz sample rate для Whisper
+                    "-ac", "1",      # моно
+                    "-f", "wav",
+                    "-y",            # перезаписать
+                    tmp_wav
+                ],
+                capture_output=True
+            )
+
+            if process.returncode != 0:
+                raise RuntimeError(f"FFmpeg failed: {process.stderr.decode()}")
+
+            # Передаем путь к файлу в pipeline
+            pipe = self._get_pipeline()
+            result = pipe(tmp_wav)
+            return result["text"].strip()
+
+        finally:
+            # Очищаем временные файлы
+            for path in [tmp_webm, tmp_wav]:
+                if path and os.path.exists(path):
+                    try:
+                        os.unlink(path)
+                    except:
+                        pass
+
+
+@lru_cache()
+def get_transcription_service() -> TranscriptionService:
+    return TranscriptionService()

requirements.txt

@@ -0,0 +1,25 @@
+# FastAPI & Server
+fastapi==0.115.0
+uvicorn[standard]==0.30.0
+python-multipart==0.0.9
+
+# LangGraph & LLM
+langgraph==0.2.60
+langchain-core==0.3.29
+anthropic==0.40.0
+
+# Whisper & Audio
+transformers==4.44.0
+torch==2.1.0
+librosa==0.10.1
+soundfile==0.12.1
+accelerate==0.27.0
+
+# CRITICAL: numpy<2 required for torch compatibility!
+numpy<2
+
+# Utilities
+pydantic==2.9.0
+pydantic-settings==2.5.0
+python-dotenv==1.0.0
+aiofiles==24.1.0