Вопрос → AnalyzerAgent → RetrieverAgent → EnrichmentAgent → GeneratorAgent → InterpreterAgent → Ответ
              ↓                  ↓                ↓                 ↓                ↓
         Намерение/Домен    Гибридный поиск    Семантические теги   Генерация запроса   Синтез ответа

from src.agents.analyzer_agent import AnalyzerAgent
from src.config import CPGConfig

config = CPGConfig()
config.set_cpg_type("postgresql")

analyzer = AnalyzerAgent(
    vector_store=vector_store,
    cpg_config=config
)

# Анализ вопроса {#analyze-a-question}
analysis = analyzer.analyze("Какие методы обрабатывают транзакции?")

# Структура результата {#result-structure}
{
    'intent': 'find_methods',           # Что хочет пользователь
    'domain': 'transaction-manager',    # Целевая подсистема
    'keywords': ['transaction'],        # Важные термины
    'query_type': 'semantic',           # Классификация запроса
    'confidence': 0.85
}

from src.agents.retriever_agent import RetrieverAgent

retriever = RetrieverAgent(
    vector_store=vector_store,
    analyzer_agent=analyzer,
    cpg_service=cpg_service,
    enable_hybrid=True
)

# Гибридный поиск {#hybrid-retrieval}
result = retriever.retrieve_hybrid(
    question="Найти шаблоны выделения памяти",
    mode="hybrid",           # hybrid, vector_only, graph_only
    query_type="structural", # Влияет на распределение весов
    top_k=10,
    use_ranker=True
)

# Структура результата {#result-structure}
{
    'results': [...],             # Сырые результаты поиска
    'ranked_results': [...],      # Ранжированные с оценками
    'retrieval_stats': {
        'total_retrieved': 15,
        'source_distribution': {'vector': 8, 'graph': 7}
    }
}

from src.agents.enrichment_agent import EnrichmentAgent

enrichment = EnrichmentAgent()

# Обогащение метода {#enrich-a-method}
enriched = enrichment.enrich_method({
    'name': 'LWLockAcquire',
    'file': 'lwlock.c',
    'signature': 'void LWLockAcquire(LWLock *lock, LWLockMode mode)'
})

# Результат {#result}
{
    'name': 'LWLockAcquire',
    'tags': ['concurrency', 'lock-acquire', 'synchronization'],
    'layer': 'concurrency-primitive',
    'security': ['thread-safe'],
    'performance': ['blocking-operation']
}

from src.agents.generator_agent import GeneratorAgent

generator = GeneratorAgent(
    vector_store=vector_store,
    cpg_config=config
)

# Генерация запроса из вопроса {#generate-query-from-question}
query = generator.generate_query(
    question="Найти всех вызывающих CommitTransaction",
    analysis={'intent': 'find_callers', 'keywords': ['CommitTransaction']},
    examples=[...]  # Извлечённые примеры
)

# Возвращает SQL-запрос {#returns-sql-query}
# "SELECT caller.full_name FROM edges_call ec JOIN nodes_method caller..." {#select-callerfull-name-from-edges-call-ec-join-nodes-method-caller}

from src.agents.interpreter_agent import InterpreterAgent

interpreter = InterpreterAgent(
    llm_interface=llm,
    cpg_config=config
)

# Интерпретация результатов {#interpret-results}
answer = interpreter.interpret(
    question="Какие методы вызывают LWLockAcquire?",
    results=[...],
    query="SELECT..."
)

# Результат {#result}
{
    'answer': 'LWLockAcquire вызывается 15 методами, включая...',
    'confidence': 0.85,
    'sources': [
        {'method': 'heap_insert', 'file': 'heapam.c', 'line': 234},
        ...
    ]
}

from src.agents.call_chain_analyzer import CallChainAnalyzer

analyzer = CallChainAnalyzer(cpg_service)

# Найти цепочку вызовов {#find-call-chain}
chain = analyzer.find_chain(
    source="executor_start",
    target="heap_insert",
    max_depth=10
)

from src.agents.logic_synthesizer import LogicSynthesizer

synthesizer = LogicSynthesizer(llm)

# Объяснить логику {#explain-logic}
explanation = synthesizer.explain_function(
    function_name="CommitTransaction",
    context=retrieved_context
)

from src.agents.adaptive_refiner import AdaptiveRefiner

refiner = AdaptiveRefiner()

# Уточнить неудачный запрос {#refine-failed-query}
refined = refiner.refine_query(
    original_query="...",
    error="Результаты не найдены",
    context=analysis
)

@dataclass
class AgentState:
    question: str
    analysis: Optional[Dict] = None
    retrieval_results: List = field(default_factory=list)
    enrichments: Dict = field(default_factory=dict)
    generated_query: Optional[str] = None
    execution_results: List = field(default_factory=list)
    answer: Optional[str] = None
    confidence: float = 0.0
    errors: List[str] = field(default_factory=list)

from typing import Dict, List, Optional

class CustomAgent:
    def __init__(self, cpg_config: Optional[CPGConfig] = None):
        self.cpg_config = cpg_config or get_global_cpg_config()

    def process(self, state: AgentState) -> AgentState:
        """Обрабатывает состояние и возвращает обновлённое состояние."""
        # Ваша логика здесь
        state.custom_results = self._analyze(state.question)
        return state

    def _analyze(self, question: str) -> Dict:
        """Внутренний метод анализа."""
        pass

from src.workflow import register_agent

register_agent("custom", CustomAgent)