serp api for gscholar working

.gitignore

@@ -0,0 +1,42 @@
+# Virtual environment
+.venv/
+venv/
+
+# Environment variables
+.env
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Logs
+*.log
+logs/
+.chainlit/*
+
+**/.DS_Store
+.DS_Store

app.py

@@ -0,0 +1,163 @@
+from typing import List, Dict, TypedDict, Union, Annotated
+import chainlit as cl
+from langgraph.graph import StateGraph, END
+from langgraph.graph.message import add_messages
+from langgraph.prebuilt import ToolNode
+from langchain_openai import ChatOpenAI
+from langchain_core.messages import HumanMessage, AIMessage, SystemMessage
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+from langchain_core.tools import BaseTool
+
+from operator import itemgetter
+from pydantic import BaseModel, Field, ConfigDict
+from saul.tools import tools
+
+from loguru import logger
+import json
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# Types for our nodes
+class AgentState(TypedDict):
+    """State for the research agent."""
+    messages: Annotated[list, add_messages]
+
+
+# Initialize the LLM
+llm = ChatOpenAI(model="gpt-4o-mini", temperature=0, streaming=True)
+
+# bind tools to the llm
+llm = llm.bind_tools(tools)
+
+
+# Agent node implementation
+async def call_model(state: AgentState) -> Dict:
+    """Agent node that decides which tool to use."""
+    logger.success(f"Calling agent model with state: {state}")
+    # print("...........................................Calling agent model...........................................")
+    # print(f"State:: {state}\n\n")
+    response = llm.invoke(state["messages"])
+    return {"messages": [response]}
+
+
+execute_tool = ToolNode(tools)
+
+# Create the graph
+uncompiled_graph = StateGraph(AgentState)
+
+# Add nodes
+uncompiled_graph.add_node("agent", call_model)
+uncompiled_graph.add_node("action", execute_tool)
+
+
+# conditional edge function
+def should_continue(state):
+    last_message = state["messages"][-1]
+
+    if last_message.tool_calls:
+        return "action"
+
+    return END
+
+
+# Add edges
+uncompiled_graph.add_conditional_edges("agent", should_continue)
+uncompiled_graph.add_edge("action", "agent")
+
+# Set entry point
+uncompiled_graph.set_entry_point("agent")
+
+# Compile the graph
+compiled_graph = uncompiled_graph.compile()
+
+system_prompt = """You are a helpful legal research assistant. 
+Only answer questions that are related to legal research, else politely decline to answer.
+Only answer the last question.
+"""
+
+@cl.on_chat_start
+async def start():
+    """Initialize the chat session."""
+    # Initialize session state
+    initial_state = AgentState(
+        messages=[SystemMessage(content=system_prompt)]
+    )
+    image = cl.Image(path="./better-call-saul-calling-card.jpg")
+
+    # Set initial state in session
+    cl.user_session.set("state", initial_state)
+
+    await cl.Message(
+        content="""### Better Call Agentic-Saul
+        🫵 Yeah! I'm Saul, your legal research assistant. 
+        I'm here to help you with your legal research needs.
+        
+        I will find information from:
+        - 📄 Legal Glossary - legal terms and definitions        
+        - 📚 Wikipedia - basic information
+        - 💬 Reddit discussions - current chatter in social media
+        - 📖 Google Scholar Case Law - judicial opinions from numerous federal and state courts
+
+        What would you like to research?""",
+        elements=[image],
+
+    ).send()
+
+
+@cl.on_message
+async def main(message: cl.Message):
+    """Handle incoming messages."""
+    # Get current session state
+    state_dict = cl.user_session.get("state")
+    state = AgentState(**state_dict)
+
+    # Update messages in state
+    state["messages"].append(HumanMessage(content=message.content))
+    inputs = {"messages": state["messages"]}
+    # try:
+    msg = cl.Message(content="")
+    # Run the graph with current state
+    async for chunk in compiled_graph.astream(inputs, stream_mode="updates"):
+        for node, values in chunk.items():
+
+            logger.success(f"Receiving update from node: {node}")
+            # print(f"-------------- Receiving update from node: '{node}' --------------")
+            await msg.stream_token(f"Receiving update from node: **{node}**\n")
+            if node == "action":
+                for tool_msg in values["messages"]:
+                    output = f"Tool used: {tool_msg.name}"
+                    # output += f"\nTool output: {tool_msg.content}"
+                    logger.success(output)
+                    # print(output)
+                    await msg.stream_token(f"{output}\n\n")
+            else: # node == "agent"
+                if values["messages"][0].tool_calls:
+                    tool_names = [tool["name"] for tool in values["messages"][0].tool_calls]
+                    output = f"Tool(s) Selected: {', '.join(tool_names)}"
+                    logger.success(output)
+                    # print(output)
+                    await msg.stream_token(f"{output}\n\n")
+                else:
+                    # output = f"\n\n\n**Final Model output**: {values['messages'][-1].content}"
+                    output = "\n**Final output**\n"
+                    logger.success(output)
+                    # print(output)
+                    print(values["messages"][-1].content)
+                    await msg.stream_token(f"{output}")
+                    # await msg.stream_token(values["messages"][-1].content)
+                    print("\n\n")
+                    
+                    # stream messages to the UI
+                    if token := values["messages"][-1].content:
+                        await msg.stream_token(token)
+
+            # Update messages in state
+            # state["messages"].extend(values["messages"])
+            # msg = cl.Message(content=values["messages"][-1].content)
+            # await message.send()
+    
+
+    # Update session state
+    cl.user_session.set("state", state)
+

chainlit.md

@@ -0,0 +1,14 @@
+# Welcome to Chainlit! 🚀🤖
+
+Hi there, Developer! 👋 We're excited to have you on board. Chainlit is a powerful tool designed to help you prototype, debug and share applications built on top of LLMs.
+
+## Useful Links 🔗
+
+- **Documentation:** Get started with our comprehensive [Chainlit Documentation](https://docs.chainlit.io) 📚
+- **Discord Community:** Join our friendly [Chainlit Discord](https://discord.gg/k73SQ3FyUh) to ask questions, share your projects, and connect with other developers! 💬
+
+We can't wait to see what you create with Chainlit! Happy coding! 💻😊
+
+## Welcome screen
+
+To modify the welcome screen, edit the `chainlit.md` file at the root of your project. If you do not want a welcome screen, just leave this file empty.

pyproject.toml

@@ -0,0 +1,44 @@
+[project]
+name = "agentic-saul"
+version = "0.1.0"
+description = "A legal research assistant powered by LangGraph and Chainlit"
+requires-python = ">=3.9,<3.12"
+readme = "README.md"
+license = { text = "MIT" }
+dependencies = [
+    "chainlit~=2.0.4",
+    "langgraph~=0.2.67",
+    "langchain~=0.3.15",
+    "langchain-community~=0.3.16",
+    "langchain-openai~=0.3.2",
+    "wikipedia~=1.4.0",
+    "praw~=7.8.1",
+    "semanticscholar~=0.9.0",
+    "python-dotenv~=1.0.1",
+    "websockets>=14.2",
+    "google-search-results~=2.4.2",
+    "loguru~=0.7.3",
+]
+
+[project.optional-dependencies]
+dev = [
+    "ruff~=0.3.3",
+    "black~=24.2.0",
+    "mypy~=1.9.0",
+]
+
+[tool.setuptools]
+packages = ["saul"]
+
+[tool.ruff]
+select = ["E", "F", "I", "N", "W", "B"]
+line-length = 100
+
+[tool.black]
+line-length = 100
+target-version = ["py39"]
+
+[tool.mypy]
+python_version = "3.9"
+strict = true
+ignore_missing_imports = true 

saul/tools.py

@@ -0,0 +1,70 @@
+from dotenv import load_dotenv
+import os
+from langchain_community.tools import tool
+
+from langchain_community.tools.reddit_search.tool import RedditSearchRun
+from langchain_community.utilities.reddit_search import RedditSearchAPIWrapper
+from langchain_community.tools.semanticscholar.tool import SemanticScholarQueryRun
+from langchain_community.tools import WikipediaQueryRun
+from langchain_community.utilities import WikipediaAPIWrapper
+# from langchain_community.tools.google_scholar import GoogleScholarQueryRun
+# from langchain_community.utilities.google_scholar import GoogleScholarAPIWrapper
+from serpapi import GoogleSearch 
+
+from loguru import logger
+
+load_dotenv()
+
+wikipedia_tool = WikipediaQueryRun(api_wrapper=WikipediaAPIWrapper())
+semantic_scholar_tool = SemanticScholarQueryRun()
+# google_scholar_tool = GoogleScholarQueryRun(api_wrapper=GoogleScholarAPIWrapper())
+reddit_tool = RedditSearchRun(
+    api_wrapper=RedditSearchAPIWrapper(
+        client_id=os.getenv("REDDIT_CLIENT_ID"),
+        client_secret=os.getenv("REDDIT_CLIENT_SECRET"),
+        user_agent=os.getenv("REDDIT_USER_AGENT")
+    )
+)
+
+# Google Scholar tool
+@tool
+def google_scholar_tool(query: str, top_k: int = 10) -> str:
+    """Search Google Scholar Case Law for judicial opinions from numerous federal and state courts in the US about the given query."""
+    params = {
+        "q": query,
+        "api_key": os.getenv("SERP_API_KEY"),
+        "engine": "google_scholar",
+        "hl": "en",
+        "as_sdt": "4",
+    }
+    logger.debug(f"Google Scholar params: {params}")
+    search = GoogleSearch(params)
+    results = search.get_dict().get("organic_results", [])
+    logger.debug(f"Google Scholar results: {results}")
+    if not results:
+        return "No good Google Scholar results found."
+
+    # Format the results
+    formatted_results = [
+        f"Title: {result.get('title', '')}\n"
+        f"Snippet: {result.get('snippet', '')}\n"
+        f"Summary: {result.get('publication_info', {}).get('summary', '')}"
+        for result in results[:top_k]  # Limit to top_k results
+    ]
+    logger.info(f"Google Scholar results: {formatted_results}")
+    return "\n\n".join(formatted_results)
+
+
+# add "rag" tool
+@tool
+def rag_tool():
+    """RAG tool."""
+    pass
+
+# Initialize tools
+tools = [
+    wikipedia_tool,
+    reddit_tool,
+    google_scholar_tool,
+    # rag_tool()
+]