Second task

Author: Zakhar-Khmurych

backend/__init__.py

@@ -0,0 +1,44 @@
+\# Popes Education and Secular Jobs
+
+
+
+\## Pope Francis (Jorge Mario Bergoglio)
+
+\- Education: Philosophy and Theology
+
+\- Secular jobs: Chemistry lab technician, literature teacher
+
+
+
+\## Pope Benedict XVI (Joseph Ratzinger)
+
+\- Education: Philosophy and Theology
+
+\- Secular jobs: None (mostly academic)
+
+
+
+\## Pope John Paul II (Karol Wojtyła)
+
+\- Education: Philosophy, Theology, Literature
+
+\- Secular jobs: Actor, poet
+
+
+
+\## Pope John Paul I (Albino Luciani)
+
+\- Education: Theology
+
+\- Secular jobs: None
+
+
+
+\## Pope Paul VI (Giovanni Battista Montini)
+
+\- Education: Theology, Canon Law
+
+\- Secular jobs: Journalist (early career)
+
+
+

backend/docs/docs/education_popes.md

@@ -0,0 +1,22 @@
+# LangGraph Interrupt Example
+
+LangGraph is a Python library for building stateful LLM applications
+using graphs or functional workflows.
+
+This document shows how interrupts can be implemented
+using both the Functional API and the Graph API.
+
+## Functional API
+
+The Functional API allows defining agent logic as a Python function.
+Interrupts are typically implemented using control flow statements.
+
+```python
+from langgraph.functional import agent
+
+def my_agent():
+    while True:
+        inp = input(">>> ")
+        if inp == "STOP":
+            return "Interrupted"
+        print(f"Echo: {inp}")

backend/docs/docs/interrupt_example.md

@@ -1,43 +1,29 @@
+import os
 import argparse
-from langchain_core.messages import HumanMessage
 from agent.graph import graph
+from agent.state import OverallState
+from langchain_core.messages import HumanMessage
 
-
-def main() -> None:
-    """Run the research agent from the command line."""
-    parser = argparse.ArgumentParser(description="Run the LangGraph research agent")
-    parser.add_argument("question", help="Research question")
-    parser.add_argument(
-        "--initial-queries",
-        type=int,
-        default=3,
-        help="Number of initial search queries",
-    )
-    parser.add_argument(
-        "--max-loops",
-        type=int,
-        default=2,
-        help="Maximum number of research loops",
-    )
-    parser.add_argument(
-        "--reasoning-model",
-        default="gemini-2.5-pro-preview-05-06",
-        help="Model for the final answer",
-    )
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("question", nargs="?", default=None, help="Question to ask")
+    parser.add_argument("--dir", required=True, help="Directory for local Markdown sources")
+    parser.add_argument("--loops", type=int, default=3, help="Max research loops")
     args = parser.parse_args()
 
-    state = {
-        "messages": [HumanMessage(content=args.question)],
-        "initial_search_query_count": args.initial_queries,
-        "max_research_loops": args.max_loops,
-        "reasoning_model": args.reasoning_model,
-    }
+    state = OverallState(
+        messages=[HumanMessage(content=args.question or "")],
+        search_dir=args.dir,
+        max_research_loops=args.loops,
+        research_loop_count=0,
+        is_sufficient=False,
+    )
 
     result = graph.invoke(state)
-    messages = result.get("messages", [])
-    if messages:
-        print(messages[-1].content)
+
+    for msg in result["messages"]:
+        print("\n" + msg.content)
 
 
 if __name__ == "__main__":
-    main()
+    main()

backend/examples/cli_research.py

@@ -1,10 +1,12 @@
 from langgraph.graph import StateGraph, START, END
-from langchain_core.messages import AIMessage, HumanMessage
+from langchain_core.messages import AIMessage
 
 from agent.state import OverallState
 from agent.tools_and_schemas import SearchQueryList, Reflection
 from agent.llm.groq import GroqLLM
 
+from .search.local_markdown import search_markdown
+
 llm = GroqLLM()
 
 
@@ -17,31 +19,41 @@ def generate_search_queries(state: OverallState):
     queries = llm.invoke_structured(prompt, SearchQueryList)
 
     return {
-        "search_query": queries.query
+        "search_query": [q.model_dump() for q in queries.query]
     }
 
 
 def web_research(state: OverallState):
-    # ❗ тимчасовий fake research
-    results = [f"Result for: {q}" for q in state["search_query"]]
+    all_results = []
+
+    search_dir = state.get("search_dir")
+    if not search_dir:
+        return {"web_research_result": [], "sources_gathered": []}
+
+    for q in state["search_query"]:
+        query_text = q["query"]
+        matches = search_markdown(search_dir, query_text)
+        all_results.extend(matches)
 
     return {
-        "web_research_result": results
+        "web_research_result": all_results,
+        "sources_gathered": []
     }
 
 
 def reflect(state: OverallState):
     prompt = (
-        f"Question: {state['messages'][-1].content}\n\n"
-        f"Research results:\n" + "\n".join(state["web_research_result"])
+        f"Question:\n{state['messages'][-1].content}\n\n"
+        f"Research:\n" + "\n".join(state["web_research_result"])
     )
 
     reflection = llm.invoke_structured(prompt, Reflection)
 
     return {
         "is_sufficient": reflection.is_sufficient,
-        "knowledge_gap": reflection.knowledge_gap,
-        "follow_up_queries": reflection.follow_up_queries,
+        "follow_up_queries": [
+            q.model_dump() for q in reflection.follow_up_queries
+        ]
     }
 
 

backend/src/__init__.py

@@ -0,0 +1,45 @@
+from pathlib import Path
+import re
+from typing import List
+
+
+def text_to_paragraphs(text: str):
+
+    return [p.strip() for p in text.split("\n\n") if p.strip()]
+
+def score_paragraph(query_tokens, paragraph):
+
+    p = paragraph.lower()
+    return sum(1 for token in query_tokens if token in p)
+
+def search_markdown(search_dir: str, query: str) -> List[str]:
+    """
+    Very simple local markdown search:
+    - scans all .md files
+    - returns paragraphs containing query keywords
+    """
+
+    results: List[str] = []
+    path = Path(search_dir)
+
+    if not path.exists():
+        return results
+
+    keywords = [w.lower() for w in query.split() if len(w) > 3]
+
+    for md_file in path.rglob("*.md"):
+        text = md_file.read_text(encoding="utf-8", errors="ignore")
+        paragraphs = text.split("\n\n")
+
+        for p in paragraphs:
+            content = p.strip()
+            if not content:
+                continue
+
+            score = sum(k in content.lower() for k in keywords)
+            if score >= 1:
+                results.append(
+                    f"[{md_file.name}]\n{content}"
+                )
+
+    return results

backend/src/agent/graph.py

@@ -1,50 +1,21 @@
 from __future__ import annotations
 
-from dataclasses import dataclass, field
-from typing import TypedDict
-
-from langgraph.graph import add_messages
+from typing import TypedDict, List
 from typing_extensions import Annotated
-
-
+from langgraph.graph import add_messages
 import operator
 
 
-
-
 class OverallState(TypedDict):
     messages: Annotated[list, add_messages]
-    search_query: Annotated[list, operator.add]
-    web_research_result: Annotated[list, operator.add]
-    sources_gathered: Annotated[list, operator.add]
-    initial_search_query_count: int
-    max_research_loops: int
-    research_loop_count: int
-    reasoning_model: str
 
+    search_query: Annotated[List[dict], operator.add]
+    web_research_result: Annotated[List[str], operator.add]
+    sources_gathered: Annotated[List[str], operator.add]
 
-class ReflectionState(TypedDict):
-    is_sufficient: bool
-    knowledge_gap: str
-    follow_up_queries: Annotated[list, operator.add]
+    initial_search_query_count: int
+    max_research_loops: int
     research_loop_count: int
-    number_of_ran_queries: int
-
-
-class Query(TypedDict):
-    query: str
-    rationale: str
-
 
-class QueryGenerationState(TypedDict):
-    search_query: list[Query]
-
-
-class WebSearchState(TypedDict):
-    search_query: str
-    id: str
-
-
-@dataclass(kw_only=True)
-class SearchStateOutput:
-    running_summary: str = field(default=None)  # Final report
+    reasoning_model: str
+    search_dir: str

backend/src/agent/search/__init__.py

@@ -2,22 +2,16 @@
 from pydantic import BaseModel, Field
 
 
+class SearchQuery(BaseModel):
+    query: str
+    rationale: str
+
+
 class SearchQueryList(BaseModel):
-    query: List[str] = Field(
-        description="A list of search queries to be used for web research."
-    )
-    rationale: str = Field(
-        description="A brief explanation of why these queries are relevant to the research topic."
-    )
+    query: List[SearchQuery]
 
 
 class Reflection(BaseModel):
-    is_sufficient: bool = Field(
-        description="Whether the provided summaries are sufficient to answer the user's question."
-    )
-    knowledge_gap: str = Field(
-        description="A description of what information is missing or needs clarification."
-    )
-    follow_up_queries: List[str] = Field(
-        description="A list of follow-up queries to address the knowledge gap."
-    )
+    is_sufficient: bool = Field(..., description="Is research sufficient?")
+    knowledge_gap: str = Field(..., description="What is missing?")
+    follow_up_queries: List[SearchQuery] = Field(default_factory=list)