first commit

.github/workflows/cicd.yml

@@ -0,0 +1,20 @@
+name: Sync to Hugging Face hub
+on:
+  push:
+    branches: [main]
+
+  # to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+jobs:
+  sync-to-hub:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+          lfs: true
+      - name: Push to hub
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+        run: git push --force https://Sharath1036:$HF_TOKEN@huggingface.co/spaces/Sharath1036/langchain-multi-agents main

.gitignore

@@ -0,0 +1,2 @@
+venv/*
+.env

node.py

@@ -0,0 +1,116 @@
+from typing import List, Literal
+from langchain_core.messages import BaseMessage, HumanMessage
+from langgraph.prebuilt import create_react_agent
+from langgraph.graph import MessagesState, END
+from langgraph.types import Command
+from weather_agent import WeatherAgent
+from pdf_agent import PDFAgent
+from langgraph.graph import StateGraph, START
+from IPython.display import Image, display
+import re
+
+def split_questions(user_message: str) -> List[str]:
+    # Naive split on ' and ', ' then ', case insensitive
+    parts = re.split(r'\band then\b|\band\b|\bthen\b', user_message, flags=re.IGNORECASE)
+    return [part.strip() for part in parts if part.strip()]
+
+def classify_question(question: str) -> Literal["pdf_agent", "weather_agent"]:
+    # Simple keyword-based classification
+    if re.search(r'\bweather\b', question, re.IGNORECASE):
+        return "weather_agent"
+    else:
+        return "pdf_agent"
+
+def pdf_agent_node(state: MessagesState) -> Command[Literal["weather_agent", END]]:
+    pdf_agent = PDFAgent(pdf_path="Sharath_OnePage.pdf")
+    user_message = None
+    for message in reversed(state["messages"]):
+        if isinstance(message, HumanMessage):
+            user_message = message.content
+            break
+    if user_message is None:
+        raise ValueError("No user message found in state.")
+
+    result = pdf_agent.agent.invoke({"input": user_message})
+    # Extract string from result
+    if isinstance(result, dict):
+        # Try common keys
+        text_result = result.get("output") or result.get("text") or str(result)
+    else:
+        text_result = str(result)
+
+    final_msg = HumanMessage(content=text_result, name="pdf_agent")
+    goto = get_next_node(final_msg, "weather_agent")
+    return Command(
+        update={"messages": state["messages"] + [final_msg]},
+        goto=goto,
+    )
+
+def weather_agent_node(state: MessagesState) -> Command[Literal["pdf_agent", END]]:
+    weather_agent = WeatherAgent()
+    user_message = None
+    for message in reversed(state["messages"]):
+        if isinstance(message, HumanMessage):
+            user_message = message.content
+            break
+    if user_message is None:
+        raise ValueError("No user message found in state.")
+
+    match = re.search(r"weather in ([\w\s,]+)", user_message, re.IGNORECASE)
+    location = match.group(1).strip() if match else user_message
+    result = weather_agent.ask(location)
+    final_msg = HumanMessage(content=result, name="weather_agent")
+    goto = get_next_node(final_msg, "pdf_agent")
+    return Command(
+        update={"messages": state["messages"] + [final_msg]},
+        goto=goto,
+    )
+
+def get_next_node(last_message: BaseMessage, goto: str):
+    if "FINAL ANSWER" in last_message.content:
+        return END
+    return goto
+
+def build_graph():
+    workflow = StateGraph(MessagesState)
+    workflow.add_node("pdf_agent", pdf_agent_node)
+    workflow.add_node("weather_agent", weather_agent_node)
+
+    workflow.add_edge(START, "pdf_agent")
+    workflow.add_edge("pdf_agent", "weather_agent")
+    workflow.add_edge("weather_agent", END)
+
+    graph = workflow.compile()
+    return graph
+
+if __name__ == "__main__":
+    graph = build_graph()
+    display(Image(graph.get_graph().draw_mermaid_png()))
+
+    # Full user input with multiple questions
+    user_input = "What organizations has Sharath worked for and tell me the weather in Mumbai"
+
+    # Split into sub-questions
+    questions = split_questions(user_input)
+
+    # Prepare empty message list to accumulate conversation
+    messages = []
+
+    # Process each question routed to the correct agent node
+    for question in questions:
+        agent_name = classify_question(question)
+        # Run the corresponding node manually with current messages + new question
+        state = {"messages": messages + [HumanMessage(content=question)]}
+        if agent_name == "pdf_agent":
+            cmd = pdf_agent_node(state)
+        else:
+            cmd = weather_agent_node(state)
+
+        # Update messages with agent response
+        messages = cmd.update["messages"]
+
+    # Print all agent responses
+    for msg in messages:
+        if not isinstance(msg, HumanMessage):
+            continue
+        print(f"{msg.name or 'user'}: {msg.content}")

pdf_agent.py

@@ -0,0 +1,102 @@
+import os
+from dotenv import load_dotenv
+from langchain.agents import AgentType, Tool, initialize_agent
+from langchain_community.agent_toolkits.load_tools import load_tools
+from langchain.chains import RetrievalQA
+from langchain_google_genai import GoogleGenerativeAIEmbeddings
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain.text_splitter import CharacterTextSplitter
+from langchain_qdrant import QdrantVectorStore
+from qdrant_client import QdrantClient
+from langchain_community.document_loaders import PyPDFLoader
+
+
+class PDFAgent:
+    def __init__(self, pdf_path: str, collection_name: str = "test"):
+        self.pdf_path = pdf_path
+        self.collection_name = collection_name
+        self._load_environment()
+        self.llm = self._initialize_llm()
+        self.embeddings = self._initialize_embeddings()
+        self.vector_store = self._initialize_vector_store()
+        self.qa_chain = self._initialize_qa_chain()
+        self.tools = self._initialize_tools()
+        self.agent = self._initialize_agent()
+
+    def _load_environment(self):
+        load_dotenv(override=True)
+        os.environ["GOOGLE_API_KEY"] = os.getenv("GOOGLE_API_KEY")
+        os.environ["QDRANT_API_KEY"] = os.getenv("QDRANT_API_KEY")
+        os.environ["QDRANT_URL"] = os.getenv("QDRANT_URL")
+        os.environ["LANGSMITH_TRACING"]= "true"
+        os.environ["LANGSMITH_API_KEY"] = os.getenv("LANGSMITH_API_KEY")
+
+    def _initialize_llm(self):
+        return ChatGoogleGenerativeAI(
+            model="gemini-2.5-flash",
+            api_key=os.getenv("GOOGLE_API_KEY"),
+            temperature=0.0,
+        )
+
+    def _initialize_embeddings(self):
+        return GoogleGenerativeAIEmbeddings(model="gemini-embedding-001")
+
+    def _initialize_vector_store(self):
+        loader = PyPDFLoader(self.pdf_path)
+        documents = loader.load()
+
+        text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
+        split_texts = text_splitter.split_documents(documents)
+
+        return QdrantVectorStore.from_documents(
+            documents=split_texts,
+            embedding=self.embeddings,
+            collection_name=self.collection_name,
+            api_key=os.getenv("QDRANT_API_KEY"),
+            url=os.getenv("QDRANT_URL"),
+            force_recreate=True
+        )
+
+    def _initialize_qa_chain(self):
+        return RetrievalQA.from_chain_type(
+            llm=self.llm,
+            chain_type="stuff",
+            retriever=self.vector_store.as_retriever()
+        )
+
+    def _initialize_tools(self):
+        tools = load_tools([], llm=self.llm)
+        tools.append(
+            Tool(
+                name="State of Union QA System",
+                func=self.qa_chain.run,
+                description=(
+                    "Useful for answering questions from the uploaded PDF. "
+                    "Input should be a fully formed question."
+                ),
+            )
+        )
+        return tools
+
+    def _initialize_agent(self):
+        return initialize_agent(
+            self.tools,
+            self.llm,
+            agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
+            verbose=True,
+        )
+
+    def ask(self, question: str):
+        print("Asking:", question)
+        result = self.agent.run(question)
+        print("Result:", result)
+        return result
+
+
+
+if __name__ == "__main__":
+    print("Starting PDF Agent...")
+    pdf_agent = PDFAgent(pdf_path="Sharath_OnePage.pdf")
+    print("Agent initialized.")
+    response = pdf_agent.ask("What all organizations has Sharath worked with?")
+    print("Response:", response)

requirements.txt

@@ -1,3 +1,15 @@
-altair
-pandas
-streamlit
+langchain
+langchain-community
+langchain-openai
+langgraph
+pyowm
+python-dotenv
+pypdf
+langchain-qdrant
+qdrant-client
+requests
+ipython
+langsmith
+openai
+streamlit
+langchain_google_genai

src/streamlit_app.py

@@ -1,40 +1,97 @@
-import altair as alt
-import numpy as np
-import pandas as pd
+import asyncio
 import streamlit as st
+import tempfile
+from pdf_agent import PDFAgent
+from weather_agent import WeatherAgent
 
-"""
-# Welcome to Streamlit!
+# Ensure an event loop exists for async libraries (fix for Google Generative AI Embeddings)
+try:
+    asyncio.get_event_loop()
+except RuntimeError:
+    asyncio.set_event_loop(asyncio.new_event_loop())
 
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+st.set_page_config(page_title="LangGraph Agents Demo", layout="wide")
+st.title("LangGraph Agents Demo")
 
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
+tab1, tab2, tab3 = st.tabs(["PDF Agent", "Weather Agent", "Multi-Agent QA"])
 
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
+with tab1:
+    st.header("PDF Agent")
+    uploaded_pdf = st.file_uploader("Upload a PDF", type=["pdf"])
+    question = st.text_input("Ask a question about the PDF:")
+    if uploaded_pdf and question:
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as tmp_file:
+            tmp_file.write(uploaded_pdf.read())
+            tmp_path = tmp_file.name
+        pdf_agent = PDFAgent(pdf_path=tmp_path)
+        with st.spinner("Processing..."):
+            answer = pdf_agent.ask(question)
+        st.success("Answer:")
+        st.write(answer)
 
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
+with tab2:
+    st.header("Weather Agent")
+    location = st.text_input("Enter a location for weather info: e.g. Mumbai")
+    if location:
+        weather_agent = WeatherAgent()
+        with st.spinner("Fetching weather..."):
+            try:
+                result = weather_agent.ask(location)
+                st.success("Weather Info:")
+                st.write(result)  # This might be None or a dict
+                # Try to extract the answer if it's a dict or object
+                # if isinstance(result, dict):
+                #     # Try common keys
+                #     if "output" in result:
+                #         st.write(result["output"])
+                #     elif "result" in result:
+                #         st.write(result["result"])
+                #     else:
+                #         st.write(str(result))
+                # elif hasattr(result, "content"):
+                #     st.write(result.content)
+                # elif result is not None:
+                #     st.write(str(result))
+            except Exception as e:
+                st.error(f"Error: {e}")
 
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+with tab3:
+    st.header("Multi-Agent QA (PDF + Weather)")
+    user_input = st.text_area("Ask multiple questions (e.g. 'What organizations has Sharath worked for and tell me the weather in Mumbai'):")
+    uploaded_pdf = st.file_uploader("Upload a PDF for PDF Agent (optional)", type=["pdf"], key="multi_pdf")
+    if st.button("Ask Multi-Agent"):
+        from node import split_questions, classify_question
+        from langchain_core.messages import HumanMessage
+        import tempfile
+        messages = []
+        # If PDF uploaded, save and use it
+        pdf_path = None
+        if uploaded_pdf:
+            with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as tmp_file:
+                tmp_file.write(uploaded_pdf.read())
+                pdf_path = tmp_file.name
+        # Split and process each question
+        questions = split_questions(user_input)
+        for question in questions:
+            agent_name = classify_question(question)
+            if agent_name == "pdf_agent":
+                if pdf_path:
+                    pdf_agent = PDFAgent(pdf_path=pdf_path)
+                else:
+                    pdf_agent = PDFAgent(pdf_path="Sharath_OnePage.pdf")
+                result = pdf_agent.agent.invoke({"input": question})
+                if isinstance(result, dict):
+                    text_result = result.get("output") or result.get("text") or str(result)
+                else:
+                    text_result = str(result)
+                messages.append(("PDF Agent", text_result))
+            else:
+                weather_agent = WeatherAgent()
+                import re
+                match = re.search(r"weather in ([\w\s,]+)", question, re.IGNORECASE)
+                location = match.group(1).strip() if match else question
+                result = weather_agent.ask(location)
+                messages.append(("Weather Agent", str(result)))
+        st.subheader("Results:")
+        for agent, answer in messages:
+            st.markdown(f"**{agent}:** {answer}")

weather_agent.py

@@ -0,0 +1,62 @@
+import os
+from langchain_community.utilities import OpenWeatherMapAPIWrapper
+from dotenv import load_dotenv
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain.agents import AgentType, Tool, initialize_agent
+
+class WeatherAgent:
+    def __init__(self):
+        self._load_environment()
+        self.weather_tool = self._initialize_weather_tool()
+        self.llm = self._initialize_llm()
+        self.tools = self._initialize_tools()
+        self.agent = self._initialize_agent()
+
+    def _load_environment(self):
+        load_dotenv(override=True)
+        os.environ["GOOGLE_API_KEY"] = os.getenv("GOOGLE_API_KEY")
+        os.environ["OPENWEATHERMAP_API_KEY"] = os.getenv("OPENWEATHERMAP_API_KEY")
+        os.environ["LANGSMITH_TRACING"]= "true"
+        os.environ["LANGSMITH_API_KEY"] = os.getenv("LANGSMITH_API_KEY")
+
+    def _initialize_weather_tool(self):
+        return OpenWeatherMapAPIWrapper()
+
+    def _initialize_llm(self):
+        return ChatGoogleGenerativeAI(
+            model="gemini-2.5-flash",
+            api_key=os.getenv("GOOGLE_API_KEY"),
+            temperature=0.0,
+        )
+
+    def _initialize_tools(self):
+        return [
+            Tool(
+                name="weather",
+                func=self.weather_tool.run,
+                description="Use this tool to get the current weather in a specified location."
+            )
+        ]
+    
+    def _initialize_agent(self):
+        return initialize_agent(
+            self.tools,
+            self.llm,
+            agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
+            verbose=True,
+        )
+
+    def ask(self, location: str):
+        prompt = f"What's the weather like in {location}?"
+        print("Asking:", prompt)
+        result = self.agent.run(prompt)
+        print("Result:", result)
+        return result
+
+if __name__ == "__main__":
+    print("Starting Weather Agent...")
+    weather_agent = WeatherAgent()
+    print("Agent initialized.")
+    location = "Avignon"  # Example location
+    response = weather_agent.ask(location)
+    print("Response:", response)