Simplify ResearchAgent + switch search backend to Tavily

- Replace hand-rolled LangGraph state machine in agents.py with
langchain.agents.create_agent (system prompt + tool loop).
- Swap search_tool from DuckDuckGo to Tavily in tools.py.
- Requirements: add spaces (HF ZeroGPU), tavily-python, langchain;
drop ddgs.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_019ryPUj8AtsFopnufGRSc4L

agents.py

@@ -1,230 +1,40 @@
 import os
-import re
-from typing import TypedDict, Annotated, Literal
 
-from pydantic import BaseModel, Field
 from langchain_groq import ChatGroq
-from langgraph.graph.message import add_messages
-from langgraph.graph import StateGraph, END
-from langchain_core.messages import AnyMessage, HumanMessage, SystemMessage
+from langchain.agents import create_agent
 
 
-class ResearchAgentState(TypedDict):
-    question: str
-    sub_questions: list[str]
-    research_findings: dict[str, str]
-    research_rounds: int
-    final_answer: str | None
-    evaluation: str | None
-    refinement_count: int
-    messages: Annotated[list[AnyMessage], add_messages]
+RESEARCH_SYSTEM_PROMPT = """You are a research specialist.
 
-
-class _Evaluation(BaseModel):
-    label: Literal["excellent", "adequate", "needs_improvement"] = Field(
-        description="Overall quality of the answer."
-    )
+For each question:
+1. Mentally break it into sub-questions if it has multiple parts.
+2. Use the search tool to find sources. When the fact is not obvious,
+   cross-check across at least 2 independent sources before concluding.
+3. Return a concise, factual answer. If the question asks for a specific
+   value (number, name, date, list), give ONLY that value in the final
+   answer. Otherwise, keep the answer under 3 sentences.
+4. Never guess. If you cannot verify, say "unknown".
+"""
 
 
 class ResearchAgent:
-    MAX_RESEARCH_ROUNDS = 5
-    MAX_REFINEMENTS = 2
-    MAX_SNIPPET_CHARS = 3000
-
     def __init__(self):
-        self.chat = ChatGroq(
+        llm = ChatGroq(
             model="openai/gpt-oss-120b",
             temperature=0.1,
             api_key=os.getenv("GROQ_API_KEY"),
         )
-        self.graph = self._build_graph()
-
-    def __call__(self, question: str) -> str:
-        return self.answer(question)
-
-    def answer(self, question: str) -> str:
-        initial_state: ResearchAgentState = {
-            "question": question,
-            "sub_questions": [],
-            "research_findings": {},
-            "research_rounds": 0,
-            "final_answer": None,
-            "evaluation": None,
-            "refinement_count": 0,
-            "messages": [HumanMessage(content=question)],
-        }
-        final_state = self.graph.invoke(initial_state)
-        return final_state["final_answer"] or "(no answer produced)"
-
-    def _build_graph(self):
-        builder = StateGraph(ResearchAgentState)
-        builder.add_node("breakdown", self.breakdown_question)
-        builder.add_node("research", self.research_with_search)
-        builder.add_node("synthesize", self.synthesize_findings)
-        builder.add_node("evaluate", self.evaluate_answer)
-        builder.add_node("refine", self.refine_answer)
-
-        builder.set_entry_point("breakdown")
-        builder.add_edge("breakdown", "research")
-        builder.add_conditional_edges(
-            "research",
-            self.select_next_step,
-            {"research": "research", "synthesize": "synthesize"},
-        )
-        builder.add_edge("synthesize", "evaluate")
-        builder.add_conditional_edges(
-            "evaluate",
-            self.needs_refinement,
-            {"refine": "refine", "complete": END},
-        )
-        builder.add_edge("refine", "evaluate")
-
-        return builder.compile()
-
-    def parse_sub_questions(self, text: str) -> list[str]:
-        lines = [ln.strip() for ln in text.splitlines() if ln.strip()]
-        cleaned: list[str] = []
-        for ln in lines:
-            stripped = re.sub(r"^(\d+[\.\)]\s+|[-*]\s+)", "", ln)
-            if stripped:
-                cleaned.append(stripped)
-        seen: set[str] = set()
-        result: list[str] = []
-        for q in cleaned:
-            if q not in seen:
-                seen.add(q)
-                result.append(q)
-        return result[:5]
-
-    def pick_next_unanswered(
-        self, sub_questions: list[str], findings: dict[str, str]
-    ) -> str | None:
-        for q in sub_questions:
-            if q not in findings:
-                return q
-        return None
-
-    def breakdown_question(self, state: ResearchAgentState) -> dict:
-        print("[Node] breakdown_question")
-        response = self.chat.invoke([
-            SystemMessage(
-                content="Break the main question into 3-5 concise, standalone sub-questions. "
-                "Return each on a new line without bullets or numbers."
-            ),
-            HumanMessage(content=state["question"]),
-        ])
-        sub_questions = self.parse_sub_questions(response.content)
-        if not sub_questions:
-            sub_questions = [state["question"]]
-        return {
-            "sub_questions": sub_questions,
-            "research_findings": {},
-            "research_rounds": 0,
-            "refinement_count": 0,
-        }
-
-    def research_with_search(self, state: ResearchAgentState) -> dict:
-        print("[Node] research_with_search")
-        next_q = self.pick_next_unanswered(
-            state["sub_questions"], state["research_findings"]
-        )
-        if next_q is None or state["research_rounds"] >= self.MAX_RESEARCH_ROUNDS:
-            return {}
-
         from tools import search_tool  # lazy: avoids circular import with tools.py
 
-        try:
-            search_results = search_tool.invoke(next_q)
-        except Exception as e:
-            search_results = f"(Search error) {e}"
-
-        response = self.chat.invoke([
-            SystemMessage(
-                content="Answer the sub-question using the provided web search snippets. "
-                "Be concise, cite key points, and avoid speculation."
-            ),
-            HumanMessage(
-                content=(
-                    f"Sub-question: {next_q}\n\n"
-                    f"Search snippets:\n{search_results[: self.MAX_SNIPPET_CHARS]}"
-                )
-            ),
-        ])
-
-        findings = {**state["research_findings"], next_q: response.content}
-        return {
-            "research_findings": findings,
-            "research_rounds": state["research_rounds"] + 1,
-        }
-
-    def select_next_step(self, state: ResearchAgentState) -> str:
-        remaining = [
-            q for q in state["sub_questions"] if q not in state["research_findings"]
-        ]
-        if remaining and state["research_rounds"] < self.MAX_RESEARCH_ROUNDS:
-            return "research"
-        return "synthesize"
-
-    def synthesize_findings(self, state: ResearchAgentState) -> dict:
-        print("[Node] synthesize_findings")
-        findings_text = "\n\n".join(
-            f"{q}:\n{a}" for q, a in state["research_findings"].items()
+        self.graph = create_agent(
+            llm,
+            tools=[search_tool],
+            system_prompt=RESEARCH_SYSTEM_PROMPT,
         )
-        response = self.chat.invoke([
-            SystemMessage(
-                content="Synthesize a clear, structured answer to the main question "
-                "using the findings provided. Be balanced, specific, and concise."
-            ),
-            HumanMessage(
-                content=(
-                    f"Main question:\n{state['question']}\n\n"
-                    f"Findings:\n{findings_text or '(No findings gathered)'}"
-                )
-            ),
-        ])
-        return {"final_answer": response.content}
-
-    def evaluate_answer(self, state: ResearchAgentState) -> dict:
-        print("[Node] evaluate_answer")
-        structured = self.chat.with_structured_output(_Evaluation)
-        try:
-            result: _Evaluation = structured.invoke([
-                SystemMessage(
-                    content="Evaluate the answer for correctness, completeness and clarity."
-                ),
-                HumanMessage(
-                    content=f"Question:\n{state['question']}\n\nAnswer:\n{state.get('final_answer') or '(empty)'}"
-                ),
-            ])
-            label = result.label
-        except Exception as e:
-            print(f"  [warn] structured eval failed: {e}; defaulting to adequate")
-            label = "adequate"
-        return {"evaluation": label}
 
-    def needs_refinement(self, state: ResearchAgentState) -> str:
-        if state["refinement_count"] >= self.MAX_REFINEMENTS:
-            return "complete"
-        if state["evaluation"] in ("excellent", "adequate"):
-            return "complete"
-        return "refine"
+    def __call__(self, question: str) -> str:
+        return self.answer(question)
 
-    def refine_answer(self, state: ResearchAgentState) -> dict:
-        print("[Node] refine_answer")
-        response = self.chat.invoke([
-            SystemMessage(
-                content="Refine the answer to address weaknesses and improve clarity, "
-                "structure, and specificity."
-            ),
-            HumanMessage(
-                content=(
-                    f"Main question:\n{state['question']}\n\n"
-                    f"Current answer:\n{state.get('final_answer') or '(empty)'}\n\n"
-                    f"Evaluation: {state.get('evaluation')}"
-                )
-            ),
-        ])
-        return {
-            "final_answer": response.content,
-            "refinement_count": state["refinement_count"] + 1,
-        }
+    def answer(self, question: str) -> str:
+        result = self.graph.invoke({"messages": [("user", question)]})
+        return result["messages"][-1].content

requirements.txt

@@ -1,8 +1,10 @@
 gradio[oauth]
 requests
 pandas
+spaces
+tavily-python
 langgraph
+langchain
 langchain-core
 langchain-groq
 langchain-community
-ddgs

tools.py

@@ -1,9 +1,35 @@
-from langchain_community.tools import DuckDuckGoSearchRun
+import os
+
 from langchain_core.tools import tool
 
 from agents import ResearchAgent
+from tavily import TavilyClient
+
+client = TavilyClient(api_key=os.environ["TAVILY_API_KEY"])
+
+
+@tool
+def search_tool(query: str) -> str:
+    """
+    Search the web for current information.
+
+    Args:
+        query: Search query.
+    """
+    results = client.search(query=query, max_results=5, search_depth="basic")
+
+    output = []
+
+    for r in results["results"]:
+        output.append(f"""
+Title: {r['title']}
+URL: {r['url']}
+Content: {r['content']}
+""")
+
+    return "\n".join(output)
+
 
-search_tool = DuckDuckGoSearchRun()
 research_agent = ResearchAgent()