Создан main.py

main.py

@@ -0,0 +1,148 @@
+import os
+import asyncio
+from typing import TypedDict, List, Dict
+
+from langchain_openai import ChatOpenAI
+from langchain_core.messages import HumanMessage
+from langchain.tools import tool
+from langgraph.graph import StateGraph, START, END
+from langchain_tavily import TavilySearchResults
+
+# ---------- LLM ----------
+llm = ChatOpenAI(
+    model="openai/gpt-oss-20b:free",
+    base_url="https://openrouter.ai/api/v1",
+    api_key=os.getenv("OPENAI_API_KEY"),
+    temperature=0.0,
+)
+
+# ---------- Tavily ----------
+search = TavilySearchResults(tavily_api_key=os.getenv("TAVILY_API_KEY"))
+
+# ---------- State ----------
+class CompareState(TypedDict):
+    entities: List[str]
+    criteria: List[str]
+    findings: Dict[str, List[str]]
+    final_table: str | None
+    verdict: str | None
+
+# ---------- Tool ----------
+@tool
+def tavily_search(query: str) -> str:
+    """Return a short summary of Tavily search results for the query."""
+    results = search.run(query)
+    snippets = []
+    for r in results[:3]:
+        snippets.append(f"{r['title']}: {r['content'][:200]}...")
+    return " | ".join(snippets)
+
+# ---------- Agent ----------
+from langchain.agents import create_openai_functions_agent
+from langchain.schema import AgentAction, AgentFinish
+
+# Simple function calling agent using the tool
+from langchain.agents import Tool, AgentExecutor
+
+agent_executor = AgentExecutor.from_agent_and_tools(
+    agent=llm,
+    tools=[Tool(name="tavily_search", func=tavily_search, description="Search the web with Tavily and return a short summary.")],
+    verbose=False,
+)
+
+# ---------- LangGraph nodes ----------
+async def plan_criteria(state: CompareState) -> CompareState:
+    entities = state["entities"]
+    prompt = f"You are given three entities: {', '.join(entities)}. Generate 3-5 concise criteria to compare them. Return a JSON array of strings."
+    response = await agent_executor.ainvoke({"input": prompt})
+    import json
+    try:
+        criteria = json.loads(response)
+    except Exception:
+        criteria = ["Performance", "Scalability", "Ease of Use"]
+    state["criteria"] = criteria
+    state["findings"] = {e: [] for e in entities}
+    return state
+
+async def research_entity(state: CompareState) -> CompareState:
+    for entity in state["entities"]:
+        for criterion in state["criteria"]:
+            if len(state["findings"][entity]) <= state["criteria"].index(criterion):
+                query = f"{entity} {criterion} comparison"
+                result = await agent_executor.ainvoke({"input": query})
+                note = result
+                state["findings"][entity].append(note)
+                print(f"[{entity} × {criterion}] найдено: {note[:60]}...")
+                return state
+    return state
+
+async def build_table(state: CompareState) -> CompareState:
+    headers = " | ".join(state["entities"]) + ""
+    rows = []
+    for criterion in state["criteria"]:
+        row = [criterion]
+        for entity in state["entities"]:
+            notes = state["findings"][entity]
+            idx = state["criteria"].index(criterion)
+            row.append(notes[idx] if idx < len(notes) else "N/A")
+        rows.append(" | ".join(row))
+    table = "| " + headers + " |\n| " + " | ".join(["---"] * len(state["entities"])) + " |\n"
+    for r in rows:
+        table += "| " + r + " |\n"
+    state["final_table"] = table
+    return state
+
+async def verdict(state: CompareState) -> CompareState:
+    prompt = f"Based on the following table, provide a concise verdict on which entity is best for which use case.\n\n{state['final_table']}"
+    result = await agent_executor.ainvoke({"input": prompt})
+    state["verdict"] = result
+    return state
+
+# ---------- Graph ----------
+from langgraph.graph import StateGraph
+
+graph = StateGraph(CompareState)
+graph.add_node("plan_criteria", plan_criteria)
+graph.add_node("research_entity", research_entity)
+graph.add_node("build_table", build_table)
+graph.add_node("verdict", verdict)
+
+graph.add_edge(START, "plan_criteria")
+graph.add_edge("plan_criteria", "research_entity")
+
+graph.add_conditional_edges(
+    "research_entity",
+    lambda state: "build_table" if all(
+        len(state["findings"][e]) == len(state["criteria"]) for e in state["entities"]
+    ) else "research_entity",
+)
+
+graph.add_edge("build_table", "verdict")
+
+graph.add_edge("verdict", END)
+
+app = graph.compile()
+
+# ---------- CLI ----------
+async def main():
+    default_entities = ["Chroma", "FAISS", "Qdrant"]
+    user_input = input("Введите 3 сущности через запятую (или нажмите Enter для по умолчанию): ")
+    if user_input.strip():
+        entities = [e.strip() for e in user_input.split(",")[:3]]
+    else:
+        entities = default_entities
+    initial_state: CompareState = {
+        "entities": entities,
+        "criteria": [],
+        "findings": {},
+        "final_table": None,
+        "verdict": None,
+    }
+    result = await app.ainvoke(initial_state)
+    print("\n--- Итоговая таблица ---")
+    print(result["final_table"])
+    print("\n--- Вердикт ---")
+    print(result["verdict"])
+
+if __name__ == "__main__":
+    asyncio.run(main())