AutoScholar

agent/graph.py

@@ -0,0 +1,36 @@
+from langgraph.graph import StateGraph, END
+from agent.state import ResearchState
+from agent.nodes.reader import reader_node
+from agent.nodes.search import search_node
+from agent.nodes.planner import planner_node
+from agent.nodes.synthesizer import synthesizer_node
+from agent.nodes.reflection import reflection_node, should_continue
+
+# Create the graph
+graph = StateGraph(ResearchState)
+
+# Add all nodes
+graph.add_node("planner", planner_node)
+graph.add_node("search", search_node)
+graph.add_node("reader", reader_node)
+graph.add_node("synthesizer", synthesizer_node)
+graph.add_node("reflection", reflection_node)
+
+# Add edges (flow between nodes)
+graph.set_entry_point("planner")
+graph.add_edge("planner", "search")
+graph.add_edge("search", "reader")
+graph.add_edge("reader", "synthesizer")
+graph.add_edge("synthesizer", "reflection")
+
+# Conditional edge - reflection either ends or loops back
+graph.add_conditional_edges(
+    "reflection",
+    should_continue,
+    {
+        "search": "search",  # loop back
+        "END": END           # finish
+    }
+)
+
+app = graph.compile()

agent/nodes/planner.py

@@ -0,0 +1,32 @@
+from agent.state import ResearchState
+from langchain_groq import ChatGroq
+
+llm = ChatGroq(model="llama-3.3-70b-versatile", api_key="")
+
+def parse_questions(text: str) -> list:
+    lines = text.strip().split("\n")
+    questions = []
+    
+    for line in lines:
+        line = line.strip()
+        if line:  # skip empty lines
+            cleaned = line.lstrip("0123456789.-) ").strip()
+            if cleaned:
+                questions.append(cleaned)
+    
+    return questions
+
+def planner_node(state: ResearchState):
+    prompt = f"""
+    You are a research planner. Break this topic into 
+    3-4 specific search queries:
+    
+    Topic: {state['topic']}
+    
+    Return only a numbered list of search queries.
+    """
+    response = llm.invoke(prompt)
+    # parse response into a list
+    sub_questions = parse_questions(response.content)
+    
+    return {"sub_questions": sub_questions}

agent/nodes/reader.py

@@ -0,0 +1,17 @@
+import httpx
+from bs4 import BeautifulSoup
+from agent.state import ResearchState
+
+def reader_node(state: ResearchState):
+    scraped = []
+    
+    for result in state['search_results'][:3]:  # top 3 only
+        try:
+            response = httpx.get(result['url'], timeout=5)
+            soup = BeautifulSoup(response.text, 'html.parser')
+            text = ' '.join(p.text for p in soup.find_all('p'))
+            scraped.append(text[:2000])  
+        except:
+            continue
+    
+    return {"scraped_content": scraped}

agent/nodes/reflection.py

@@ -0,0 +1,29 @@
+from agent.state import ResearchState
+from langchain_groq import ChatGroq
+
+llm = ChatGroq(model="llama-3.3-70b-versatile", api_key="")
+
+def reflection_node(state: ResearchState):
+    prompt = f"""
+    Original question: {state['topic']}
+    
+    Generated report: {state['report']}
+    
+    Does this report fully and accurately answer the 
+    original question? Reply with only YES or NO, 
+    then one sentence explanation.
+    """
+    response = llm.invoke(prompt)
+    passed = response.content.strip().upper().startswith("YES")
+    
+    return {
+        "reflection_passed": passed,
+        "loop_count": state['loop_count'] + 1
+    }
+
+# decides the next node based on state
+def should_continue(state: ResearchState):
+    if state['reflection_passed'] or state['loop_count'] >= 2:
+        return "END"
+    else:
+        return "search"  # loop back and search again

agent/nodes/search.py

@@ -0,0 +1,13 @@
+from tavily import TavilyClient
+from agent.state import ResearchState
+
+tavily = TavilyClient(api_key="")
+
+def search_node(state: ResearchState):
+    all_results = []
+    
+    for question in state['sub_questions']:
+        results = tavily.search(question, max_results=3)
+        all_results.extend(results['results'])
+    
+    return {"search_results": all_results}

agent/nodes/synthesizer.py

@@ -0,0 +1,21 @@
+from langchain_groq import ChatGroq
+from agent.state import ResearchState
+
+llm = ChatGroq(model="llama-3.3-70b-versatile", api_key="")
+
+def synthesizer_node(state: ResearchState):
+    content = "\n\n".join(state['scraped_content'])
+    
+    prompt = f"""
+    You are a research analyst. Using the content below,
+    write a comprehensive structured report on:
+    
+    Topic: {state['topic']}
+    
+    Content: {content}
+    
+    Format: Introduction, Key Findings, Conclusion, Sources
+    """
+    response = llm.invoke(prompt)
+    
+    return {"report": response.content}

agent/state.py

@@ -0,0 +1,10 @@
+from typing import TypedDict, List
+
+class ResearchState(TypedDict):
+    topic: str                  # user's original question
+    sub_questions: List[str]    # broken down by planner node
+    search_results: List[dict]  # raw results from Tavily
+    scraped_content: List[str]  # full page text
+    report: str                 # final synthesized report
+    reflection_passed: bool     # did reflection approve?
+    loop_count: int             # prevent infinite loops

streamlit.py

@@ -0,0 +1,21 @@
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+import streamlit as st
+from agent.graph import app
+
+st.title("AI Research Assistant")
+topic = st.text_input("Enter research topic:")
+
+if st.button("Research"):
+    with st.spinner("Agent is researching..."):
+        result = app.invoke({
+            "topic": topic,
+            "sub_questions": [],
+            "search_results": [],
+            "scraped_content": [],
+            "report": "",
+            "reflection_passed": False,
+            "loop_count": 0
+        })
+    st.markdown(result['report'])