working locally

.chainlit/config.toml

@@ -0,0 +1,139 @@
+[project]
+# Whether to enable telemetry (default: true). No personal data is collected.
+enable_telemetry = true
+
+
+# List of environment variables to be provided by each user to use the app.
+user_env = []
+
+# Duration (in seconds) during which the session is saved when the connection is lost
+session_timeout = 3600
+
+# Duration (in seconds) of the user session expiry
+user_session_timeout = 1296000  # 15 days
+
+# Enable third parties caching (e.g., LangChain cache)
+cache = false
+
+# Authorized origins
+allow_origins = ["*"]
+
+[features]
+# Process and display HTML in messages. This can be a security risk (see https://stackoverflow.com/questions/19603097/why-is-it-dangerous-to-render-user-generated-html-or-javascript)
+unsafe_allow_html = false
+
+# Process and display mathematical expressions. This can clash with "$" characters in messages.
+latex = false
+
+# Autoscroll new user messages at the top of the window
+user_message_autoscroll = true
+
+# Automatically tag threads with the current chat profile (if a chat profile is used)
+auto_tag_thread = true
+
+# Allow users to edit their own messages
+edit_message = true
+
+# Authorize users to spontaneously upload files with messages
+[features.spontaneous_file_upload]
+    enabled = true
+    # Define accepted file types using MIME types
+    # Examples:
+    # 1. For specific file types:
+    #    accept = ["image/jpeg", "image/png", "application/pdf"]
+    # 2. For all files of certain type:
+    #    accept = ["image/*", "audio/*", "video/*"]
+    # 3. For specific file extensions:
+    #    accept = { "application/octet-stream" = [".xyz", ".pdb"] }
+    # Note: Using "*/*" is not recommended as it may cause browser warnings
+    accept = ["*/*"]
+    max_files = 20
+    max_size_mb = 500
+
+[features.audio]
+    # Sample rate of the audio
+    sample_rate = 24000
+
+[features.mcp.sse]
+    enabled = true
+
+[features.mcp.stdio]
+    enabled = true
+    # Only the executables in the allow list can be used for MCP stdio server.
+    # Only need the base name of the executable, e.g. "npx", not "/usr/bin/npx".
+    # Please don't comment this line for now, we need it to parse the executable name.
+    allowed_executables = [ "npx", "uvx" ]
+
+[UI]
+# Name of the app and chatbot.
+name = "Research Assistant"
+
+# Description of the app and chatbot. This is used for HTML metadata.
+description = "Research Assistant powered by LangGraph and LangChain"
+
+# The default value for the expand messages settings.
+default_expand_messages = true
+
+# Hide the chain of thought details from the user.
+hide_cot = false
+
+# Link to your github repo. This will add a github button in the UI's header.
+github = ""
+
+# Override default MUI light theme. (Ref: https://mui.com/material-ui/customization/default-theme/)
+[UI.theme.light]
+background = "#FAFAFA"
+paper = "#FFFFFF"
+
+# Override default MUI dark theme. (Ref: https://mui.com/material-ui/customization/default-theme/)
+[UI.theme.dark]
+background = "#1F1F1F"
+paper = "#0F0F0F"
+
+# default_theme = "dark"
+
+# layout = "wide"
+
+# default_sidebar_state = "open"
+
+# Chain of Thought (CoT) display mode. Can be "hidden", "tool_call" or "full".
+cot = "full"
+
+# Specify a CSS file that can be used to customize the user interface.
+# The CSS file can be served from the public directory or via an external link.
+# custom_css = "/public/test.css"
+
+# Specify additional attributes for a custom CSS file
+# custom_css_attributes = "media=\"print\""
+
+# Specify a JavaScript file that can be used to customize the user interface.
+# The JavaScript file can be served from the public directory.
+# custom_js = "/public/test.js"
+
+# Specify additional attributes for custom JS file
+# custom_js_attributes = "async type = \"module\""
+
+# Custom login page image, relative to public directory or external URL
+# login_page_image = "/public/custom-background.jpg"
+
+# Custom login page image filter (Tailwind internal filters, no dark/light variants)
+# login_page_image_filter = "brightness-50 grayscale"
+# login_page_image_dark_filter = "contrast-200 blur-sm"
+
+# Specify a custom meta image url.
+# custom_meta_image_url = "https://chainlit-cloud.s3.eu-west-3.amazonaws.com/logo/chainlit_banner.png"
+
+# Specify a custom build directory for the frontend.
+# This can be used to customize the frontend code.
+# Be careful: If this is a relative path, it should not start with a slash.
+# custom_build = "./public/build"
+
+# Specify optional one or more custom links in the header.
+# [[UI.header_links]]
+#     name = "Issues"
+#     display_name = "Report Issue"
+#     icon_url = "https://avatars.githubusercontent.com/u/128686189?s=200&v=4"
+#     url = "https://github.com/Chainlit/chainlit/issues"
+
+[meta]
+generated_by = "0.7.700"

.gitignore

@@ -0,0 +1,92 @@
+# 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
+MANIFEST
+
+# Python virtual environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Project specific
+*.egg-info/
+src/research_agent_langgraph.egg-info/
+.files/
+
+# Distribution / packaging
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyCharm
+.idea/
+
+# VS Code
+.vscode/
+*.code-workspace
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# Environment variables
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# API keys
+*.pem
+
+# macOS
+.DS_Store
+
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Chainlit - ignore everything in .chainlit except config.toml
+.chainlit/*
+!.chainlit/config.toml
+
+# Local files
+*.local 

.python-version

@@ -0,0 +1 @@
+3.13

Dockerfile

@@ -0,0 +1,70 @@
+# Get a distribution that has uv already installed
+FROM ghcr.io/astral-sh/uv:python3.10-bookworm-slim
+
+# Add Rust compiler installation for dependencies that might need it
+USER root
+RUN apt-get update && apt-get install -y \
+    curl \
+    build-essential \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
+ENV PATH="/root/.cargo/bin:${PATH}"
+
+# Add user - this is the user that will run the app
+RUN useradd -m -u 1000 user
+USER user
+
+# Set up Rust for the user
+RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
+ENV PATH="/home/user/.cargo/bin:${PATH}"
+
+# Set the home directory and path
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH        
+
+# Set Python environment variables
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PYTHONPATH=/home/user/app \
+    UVICORN_WS_PROTOCOL=websockets
+
+# Set the working directory
+WORKDIR $HOME/app
+
+# First copy all files needed for dependency installation
+COPY --chown=user pyproject.toml $HOME/app/
+COPY --chown=user README.md $HOME/app/
+# Create src directory
+RUN mkdir -p $HOME/app/src
+
+# Copy dependencies first
+COPY --chown=user requirements.txt* $HOME/app/
+
+
+# Now copy the rest of the application (improves Docker build caching)
+COPY --chown=user . $HOME/app/
+
+# Create required directories for Chainlit
+RUN mkdir -p $HOME/app/.chainlit
+RUN mkdir -p $HOME/.cache
+
+# Install application with uv sync again after all files are present
+RUN uv sync
+
+# Create .env file from environment variables at runtime
+RUN echo "#!/bin/bash" > $HOME/app/entrypoint.sh && \
+    echo "# Create .env file from environment variables" >> $HOME/app/entrypoint.sh && \
+    echo "if [ ! -f .env ]; then" >> $HOME/app/entrypoint.sh && \
+    echo '    echo "OPENAI_API_KEY=$OPENAI_API_KEY" > .env' >> $HOME/app/entrypoint.sh && \
+    echo '    echo "TAVILY_API_KEY=$TAVILY_API_KEY" >> .env' >> $HOME/app/entrypoint.sh && \
+    echo "fi" >> $HOME/app/entrypoint.sh && \
+    echo "# Run the application" >> $HOME/app/entrypoint.sh && \
+    echo 'uv run chainlit run app.py --host "0.0.0.0" --port "7860"' >> $HOME/app/entrypoint.sh && \
+    chmod +x $HOME/app/entrypoint.sh
+
+# Expose the port
+EXPOSE 7860
+
+# Run the app using the entrypoint script
+CMD ["./entrypoint.sh"]

PROJECT_README.md

@@ -0,0 +1,75 @@
+# Research Agent with LangGraph
+
+This project implements a research agent using LangGraph and LangChain. The agent is capable of researching any domain using three powerful tools and can be deployed with a Chainlit frontend.
+
+## Features
+
+- Domain-specific research assistant
+- Three specialized research tools:
+  1. Web Search - For general queries and recent information
+  2. Research Paper Search - For academic papers and scientific information
+  3. Data Analysis - For analyzing data provided by the user
+- Interactive Chainlit web interface
+- Configurable research domain
+
+## Architecture
+
+This project uses:
+- **LangGraph**: For creating the agent's workflow graph with cyclic behavior
+- **LangChain**: For tool integration and language model interactions
+- **Chainlit**: For the web-based frontend
+- **OpenAI GPT-4o**: As the underlying language model
+
+## Installation
+
+1. Clone this repository
+2. Install dependencies using UV (recommended) or pip:
+
+```bash
+# Using UV
+uv pip install -r requirements.txt
+```
+
+## Configuration
+
+1. Create a `.env` file in the project root with the following content:
+
+```
+OPENAI_API_KEY=your_openai_api_key
+TAVILY_API_KEY=your_tavily_api_key
+```
+
+## Usage
+
+To run the application:
+
+```bash
+chainlit run app.py -w
+```
+
+This will start the Chainlit server and open a web browser with the interface.
+
+## File Structure
+
+- `agent.py`: Contains the LangGraph implementation of the research agent
+- `tools.py`: Defines the three research tools
+- `app.py`: Chainlit web interface 
+- `chainlit.md`: Welcome page content for Chainlit
+- `requirements.txt`: Dependencies for the project
+
+## Customization
+
+You can customize the agent by:
+1. Modifying the `DOMAIN` variable in `app.py`
+2. Adding new tools in `tools.py`
+3. Changing the system prompt in `agent.py`
+
+## Example Queries
+
+- "What are the latest developments in quantum computing?"
+- "Find research papers about climate change impacts on agriculture"
+- "Analyze this data: [paste JSON or CSV]"
+
+## License
+
+MIT 

README.md

@@ -10,3 +10,76 @@ short_description: agent tool chainlit demo
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+<p align = "center" draggable="false" ><img src="https://github.com/AI-Maker-Space/LLM-Dev-101/assets/37101144/d1343317-fa2f-41e1-8af1-1dbb18399719"
+     width="200px"
+     height="auto"/>
+</p>
+
+## <h1 align="center" id="heading">Session 5: Our First Agent with LangGraph</h1>
+
+| 🤓 Pre-work | 📰 Session Sheet | ⏺️ Recording     | 🖼️ Slides        | 👨‍💻 Repo         | 📝 Homework | 📁 Feedback       |
+|:-----------------|:-----------------|:-----------------|:-----------------|:-----------------|:-----------------|:-----------------|
+| [Session 5: Pre-Work](https://www.notion.so/Session-5-Agents-with-LangGraph-1c8cd547af3d81068e44d4e4b901a9a8?pvs=4#1c8cd547af3d81578bedd1d2b11ab888)| [Session 5: Agents with LangGraph](https://www.notion.so/Session-5-Agents-with-LangGraph-1c8cd547af3d81068e44d4e4b901a9a8) | [Recording](https://us02web.zoom.us/rec/play/YvHRbOKYx8QDcTMwli7QjH-npGauB8wkk2gcN7ax7TV_oxQZbPRPdyxUebtH91uVQ8lRgCbP6u0iicmP.Vvroz4VC2XA7DILn?accessLevel=meeting&canPlayFromShare=true&from=my_recording&continueMode=true&componentName=rec-play&originRequestUrl=https%3A%2F%2Fus02web.zoom.us%2Frec%2Fshare%2F-fJk79tgwkAw3gJS0V69OeDvOUJ0EUE0qgOFey9-1uJPnL6oNT6vLmVygOWHl-JV.mYe1JWztYuHqsYWx)  (ck*A3y%t) | [Session 5: Agents](https://www.canva.com/design/DAGjaRyDT1Y/Sy7YaHwHOc19gomlhpq7hw/edit?utm_content=DAGjaRyDT1Y&utm_campaign=designshare&utm_medium=link2&utm_source=sharebutton)| You Are Here!| [Session 5 Assignment: Agents with LangGraph](https://forms.gle/bA9BN2bgNLMNB9HXA)| [AIE6 Feedback 4/15](https://forms.gle/Fgb5K4PDKokvtX787)
+
+
+In today's assignment, we'll be creating an Agentic LangChain RAG Application.
+
+- 🤝 Breakout Room #1:
+  1. Install required libraries
+  2. Set Environment Variables
+  3. Creating our Tool Belt
+  4. Creating Our State
+  5. Creating and Compiling A Graph!
+  
+- 🤝 Breakout Room #2:
+  - Part 1: LangSmith Evaluator:
+    1. Creating an Evaluation Dataset
+    2. Adding Evaluators
+  - Part 2:
+    3. Adding Helpfulness Check and "Loop" Limits
+    4. LangGraph for the "Patterns" of GenAI
+
+### Advanced Build
+
+You are tasked to create an agent with 3 tools that can research a specific domain of your choice.
+
+You must deploy the resultant agent with a Chainlit (or Custom) frontend.
+
+## Ship 🚢
+
+The completed notebook!
+
+### Deliverables
+
+- A short Loom of the notebook, and a 1min. walkthrough of the application in full
+
+## Share 🚀
+
+Make a social media post about your final application!
+
+### Deliverables
+
+- Make a post on any social media platform about what you built!
+
+Here's a template to get you started:
+
+```
+🚀 Exciting News! 🚀
+
+I am thrilled to announce that I have just built and shipped an Agentic Retrieval Augmented Generation Application with LangChain! 🎉🤖
+
+🔍 Three Key Takeaways:
+1️⃣ 
+2️⃣ 
+3️⃣ 
+
+Let's continue pushing the boundaries of what's possible in the world of AI and question-answering. Here's to many more innovations! 🚀
+Shout out to @AIMakerspace !
+
+#LangChain #QuestionAnswering #RetrievalAugmented #Innovation #AI #TechMilestone
+
+Feel free to reach out if you're curious or would like to collaborate on similar projects! 🤝🔥
+```
+
+> #### NOTE: PLEASE SHUTDOWN YOUR INSTANCES WHEN YOU HAVE COMPLETED THE ASSIGNMENT TO PREVENT UNESSECARY CHARGES.

app.py

@@ -0,0 +1,242 @@
+import os
+import sys
+import chainlit as cl
+from src.research_agent import run_agent, create_system_message
+from langchain_core.messages import (
+    AIMessage,
+    HumanMessage,
+    SystemMessage,
+    ToolMessage,
+)
+
+# Set domain as global variable
+DOMAIN = "General Research"
+DEBUG_MODE = True  # Set to True to show detailed tool usage
+
+# List of available domains
+AVAILABLE_DOMAINS = [
+    "General Research",
+    "Computer Science",
+    "Medicine",
+    "Finance",
+    "Climate Science",
+    "Artificial Intelligence",
+    "History",
+    "Psychology",
+    "Physics",
+    "Biology"
+]
+
+@cl.on_chat_start
+async def on_chat_start():
+    """
+    Initialize the chat session
+    """
+    # Set up the session state
+    cl.user_session.set("messages", [create_system_message(DOMAIN)])
+    cl.user_session.set("debug_mode", DEBUG_MODE)
+    
+    # Send a welcome message
+    await cl.Message(
+        content=f"Hello! I'm your research assistant specialized in {DOMAIN}. How can I help you?\n\n"
+                f"I have access to the following tools:\n"
+                f"1. 🔎 Web Search - For recent information and general queries\n"
+                f"2. 📄 Research Papers - For academic and scientific knowledge\n"
+                f"3. 📚 Wikipedia - For background information and factual summaries\n"
+                f"4. 📊 Data Analysis - For analyzing data you provide\n\n"
+                f"You can change the research domain by typing `/domain` followed by one of these options:\n"
+                f"{', '.join(AVAILABLE_DOMAINS)}\n\n"
+                f"You can toggle debug mode with `/debug on` or `/debug off` to see detailed tool usage.",
+        author="Research Assistant"
+    ).send()
+
+@cl.on_settings_update
+async def on_settings_update(settings):
+    """
+    Handle settings updates
+    """
+    global DOMAIN
+    
+    if "domain" in settings:
+        DOMAIN = settings["domain"]
+        # Reset messages with new domain
+        cl.user_session.set("messages", [create_system_message(DOMAIN)])
+        
+        # Notify user of domain change
+        await cl.Message(
+            content=f"Domain changed to {DOMAIN}. My knowledge is now specialized for this domain.",
+            author="System"
+        ).send()
+
+@cl.on_message
+async def on_message(message: cl.Message):
+    """
+    Process incoming messages
+    """
+    global DOMAIN, DEBUG_MODE
+    
+    # Check for debug mode command
+    if message.content.startswith("/debug"):
+        command_parts = message.content.split()
+        if len(command_parts) > 1:
+            if command_parts[1].lower() == "on":
+                DEBUG_MODE = True
+                cl.user_session.set("debug_mode", True)
+                await cl.Message(
+                    content="Debug mode turned ON. You'll see detailed tool usage information.",
+                    author="System"
+                ).send()
+            elif command_parts[1].lower() == "off":
+                DEBUG_MODE = False
+                cl.user_session.set("debug_mode", False)
+                await cl.Message(
+                    content="Debug mode turned OFF.",
+                    author="System"
+                ).send()
+        else:
+            current_state = "ON" if DEBUG_MODE else "OFF"
+            await cl.Message(
+                content=f"Debug mode is currently {current_state}. Use `/debug on` or `/debug off` to change.",
+                author="System"
+            ).send()
+        return
+    
+    # Check for domain change command
+    if message.content.startswith("/domain"):
+        command_parts = message.content.split()
+        if len(command_parts) == 1:
+            # Display available domains
+            domains_list = "\n".join([f"- {domain}" for domain in AVAILABLE_DOMAINS])
+            await cl.Message(
+                content=f"Please specify a domain. Available domains:\n{domains_list}\n\nExample: `/domain Artificial Intelligence`",
+                author="System"
+            ).send()
+            return
+        
+        # Get the requested domain
+        requested_domain = " ".join(command_parts[1:])
+        
+        # Check if it's in the available domains (case insensitive)
+        found_domain = None
+        for domain in AVAILABLE_DOMAINS:
+            if domain.lower() == requested_domain.lower():
+                found_domain = domain
+                break
+        
+        if found_domain:
+            DOMAIN = found_domain
+            # Reset messages with new domain
+            cl.user_session.set("messages", [create_system_message(DOMAIN)])
+            
+            # Notify user of domain change
+            await cl.Message(
+                content=f"Domain changed to {DOMAIN}. My knowledge is now specialized for this domain.",
+                author="Research Assistant"
+            ).send()
+        else:
+            # Domain not found
+            domains_list = "\n".join([f"- {domain}" for domain in AVAILABLE_DOMAINS])
+            await cl.Message(
+                content=f"Domain '{requested_domain}' not found. Available domains:\n{domains_list}",
+                author="System"
+            ).send()
+        return
+    
+    # Get current message history and debug mode setting
+    messages = cl.user_session.get("messages")
+    debug_mode = cl.user_session.get("debug_mode", DEBUG_MODE)
+    
+    # Add user message to history
+    user_message = HumanMessage(content=message.content)
+    
+    # Create a temporary thinking message
+    thinking = cl.Message(content="Researching your query...", author="Research Assistant")
+    await thinking.send()
+    
+    try:
+        # Call the agent
+        response_messages = run_agent(
+            user_input=message.content,
+            domain=DOMAIN,
+            messages=messages
+        )
+        
+        # Update the thinking message
+        await thinking.remove()
+        
+        # Track tool usage for summary
+        tool_usage = []
+        
+        # Process and display messages
+        for msg in response_messages:
+            if not msg in messages:  # Only process new messages
+                if isinstance(msg, AIMessage):
+                    await cl.Message(
+                        content=msg.content,
+                        author="Research Assistant"
+                    ).send()
+                elif isinstance(msg, ToolMessage):
+                    # Add to tool usage list
+                    tool_usage.append(msg.name)
+                    
+                    # Create elements for tool output
+                    elements = []
+                    
+                    # Format the tool output for better readability
+                    formatted_content = msg.content
+                    # Try to detect JSON and format it
+                    if msg.content.strip().startswith('{') or msg.content.strip().startswith('['):
+                        try:
+                            import json
+                            content_obj = json.loads(msg.content)
+                            formatted_content = json.dumps(content_obj, indent=2)
+                        except:
+                            pass
+                    
+                    # Add tool output as an element
+                    elements.append(
+                        cl.Text(
+                            name=f"Tool Result: {msg.name}",
+                            content=formatted_content,
+                            display="inline"
+                        )
+                    )
+                    
+                    # Only show detailed tool messages in debug mode
+                    if debug_mode:
+                        # Send tool message with more prominent styling
+                        await cl.Message(
+                            content=f"🔍 **TOOL CALL**: `{msg.name}`\n\nI used this tool to find information about your query.",
+                            author="Research Assistant",
+                            elements=elements
+                        ).send()
+        
+        # Display tool usage summary if tools were used
+        if tool_usage and debug_mode:
+            tool_counts = {}
+            for tool in tool_usage:
+                if tool in tool_counts:
+                    tool_counts[tool] += 1
+                else:
+                    tool_counts[tool] = 1
+            
+            summary = "📊 **RESEARCH SUMMARY**\n\nTo answer your question, I used:\n"
+            for tool, count in tool_counts.items():
+                # Add emoji based on tool type
+                emoji = "🔎" if tool == "web_search" else "📄" if tool == "research_paper_search" else "📚" if tool == "wikipedia_search" else "📊"
+                summary += f"- {emoji} `{tool}`: {count} time{'s' if count > 1 else ''}\n"
+            
+            await cl.Message(
+                content=summary,
+                author="System"
+            ).send()
+        
+        # Update session with new messages
+        cl.user_session.set("messages", response_messages)
+        
+    except Exception as e:
+        await thinking.remove()
+        await cl.Message(
+            content=f"Sorry, I encountered an error: {str(e)}",
+            author="System"
+        ).send() 

chainlit.md

@@ -0,0 +1,46 @@
+# Research Assistant Agent
+
+This application is a research assistant powered by LangGraph and LangChain. It can help you find information on various topics using three specialized tools:
+
+## Available Tools
+
+1. **Web Search**: For general queries and recent information
+2. **Research Paper Search**: For academic and scientific research papers
+3. **Data Analysis**: For analyzing data sets you provide in JSON or CSV format
+
+## How to Use
+
+1. Choose your research domain in the settings panel
+2. Ask any question related to your chosen domain
+3. The agent will use the appropriate tools to research and answer your question
+
+## Example Queries
+
+- "What are the latest developments in quantum computing?"
+- "Find research papers about climate change impacts on agriculture"
+- "Analyze this data: [paste JSON or CSV]"
+
+## Tips
+
+- Be specific in your questions for better results
+- For data analysis, make sure your data is properly formatted
+- Change the domain setting to get more specialized answers for your topic
+
+---
+settings:
+  - name: domain
+    title: Research Domain
+    description: Specialized domain for the research assistant
+    type: select
+    default: General Research
+    options:
+      - General Research
+      - Computer Science
+      - Medicine
+      - Finance
+      - Climate Science
+      - Artificial Intelligence
+      - History
+      - Psychology
+      - Physics
+      - Biology 

pyproject.toml

@@ -0,0 +1,30 @@
+[project]
+name = "research-agent-langgraph"
+version = "0.1.0"
+description = "Research Agent with LangGraph and Chainlit"
+readme = "PROJECT_README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "langchain==0.3.15",
+    "langchain-community==0.3.15",
+    "langchain-openai==0.3.2",
+    "langgraph==0.2.67",
+    "chainlit==2.5.5",
+    "pandas>=2.0.0",
+    "arxiv>=1.4",
+    "tavily-python",
+    "pydantic>=2.0.0",
+    "typing-extensions>=4.5.0",
+    "websockets>=11.0.0",
+
+]
+
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.uv]
+pip = { only-binary = ["numpy"] }

run.py

@@ -0,0 +1,78 @@
+import os
+import sys
+from src.research_agent import run_agent
+from langchain_core.messages import AIMessage, ToolMessage
+
+def main():
+    """
+    Run the research agent from the command line
+    """
+    # Check if domain is provided
+    if len(sys.argv) >= 2:
+        domain = sys.argv[1]
+    else:
+        domain = "General Research"
+        print(f"No domain specified, using default: {domain}")
+    
+    print(f"\n=== Research Assistant ({domain}) ===\n")
+    print("Ask your question or type 'exit' to quit.\n")
+    
+    # Main interaction loop
+    messages = None
+    while True:
+        # Get user input
+        user_input = input("> ")
+        
+        # Check for exit command
+        if user_input.lower() in ["exit", "quit", "q"]:
+            print("\nGoodbye!")
+            break
+
+        try:    
+            # Run the agent
+            print("\nResearching...\n")
+            messages = run_agent(user_input, domain, messages)
+            
+            # Print AI response
+            for message in messages[-3:]:  # Print only the last few messages
+                if hasattr(message, "type") and message.type == "ai":
+                    print(f"\nAssistant: {message.content}\n")
+                elif hasattr(message, "type") and message.type == "tool" and hasattr(message, "name"):
+                    print(f"\n[Tool: {message.name}]\n{message.content[:200]}...\n" 
+                          if len(message.content) > 200 else f"\n[Tool: {message.name}]\n{message.content}\n")
+                elif hasattr(message, "content"):
+                    if isinstance(message, AIMessage):
+                        print(f"\nAssistant: {message.content}\n")
+                    elif isinstance(message, ToolMessage) and hasattr(message, "name"):
+                        print(f"\n[Tool: {message.name}]\n{message.content[:200]}...\n" 
+                              if len(message.content) > 200 else f"\n[Tool: {message.name}]\n{message.content}\n")
+        except Exception as e:
+            print(f"\nError: {str(e)}\n")
+            print("Let's try again with a different question.")
+
+if __name__ == "__main__":
+    # Check for environment variables
+    if not os.environ.get("OPENAI_API_KEY"):
+        try:
+            from dotenv import load_dotenv
+            load_dotenv()
+        except ImportError:
+            pass
+            
+        if not os.environ.get("OPENAI_API_KEY"):
+            api_key = input("Enter your OpenAI API key: ")
+            os.environ["OPENAI_API_KEY"] = api_key
+    
+    if not os.environ.get("TAVILY_API_KEY"):
+        if os.path.exists(".env"):
+            try:
+                from dotenv import load_dotenv
+                load_dotenv()
+            except ImportError:
+                pass
+                
+        if not os.environ.get("TAVILY_API_KEY"):
+            api_key = input("Enter your Tavily API key: ")
+            os.environ["TAVILY_API_KEY"] = api_key
+    
+    main() 

setup_and_run.sh

@@ -0,0 +1,41 @@
+#!/bin/bash
+
+# Check if UV is installed
+if ! command -v uv &> /dev/null; then
+    echo "UV is not installed. Please install UV first."
+    echo "You can install it using: curl -sSf https://install.ultraviolet.rs | sh"
+    exit 1
+fi
+
+# Set up virtual environment if it doesn't exist
+if [ ! -d ".venv" ]; then
+    echo "Setting up virtual environment..."
+    python -m venv .venv
+fi
+
+# Activate virtual environment
+source .venv/bin/activate
+
+# Install dependencies using UV
+echo "Installing dependencies with UV from pyproject.toml..."
+uv pip install -e .
+
+# Check if .env file exists
+if [ ! -f ".env" ]; then
+    echo "Creating .env file..."
+    
+    echo "Enter your OpenAI API key:"
+    read OPENAI_API_KEY
+    
+    echo "Enter your Tavily API key:"
+    read TAVILY_API_KEY
+    
+    echo "OPENAI_API_KEY=$OPENAI_API_KEY" > .env
+    echo "TAVILY_API_KEY=$TAVILY_API_KEY" >> .env
+    
+    echo ".env file created successfully!"
+fi
+
+# Run the application with chainlit
+echo "Starting the Research Agent with Chainlit..."
+chainlit run app.py -w 

src/__init__.py

@@ -0,0 +1,3 @@
+"""Research Agent with LangGraph and Chainlit."""
+
+__version__ = "0.1.0" 

src/research_agent/__init__.py

@@ -0,0 +1,3 @@
+"""Research agent implementation with LangGraph."""
+
+from .agent import run_agent, create_agent_graph, create_system_message 

src/research_agent/agent.py

@@ -0,0 +1,131 @@
+import os
+from typing import Dict, TypedDict, List, Annotated, Literal, Union, Any
+from .tools import get_tools
+from langchain_openai import ChatOpenAI
+from langchain.prompts import ChatPromptTemplate
+from langgraph.graph import StateGraph, START, END
+import operator
+from langchain_core.messages import (
+    AIMessage,
+    HumanMessage,
+    SystemMessage,
+    ToolMessage,
+    FunctionMessage,
+)
+from langchain_core.tools import BaseTool, tool
+from langgraph.graph.message import add_messages
+from langgraph.prebuilt import ToolNode, tools_condition
+import json
+
+# State definition
+class AgentState(TypedDict):
+    messages: Annotated[list, add_messages]
+
+# Initialize tools
+tools = get_tools()
+
+# System prompt
+system_prompt = """You are an AI research assistant specialized in {domain}.
+Your goal is to help users find accurate information about {domain} topics.
+
+You have access to the following tools:
+1. Web Search - For general queries and recent information
+2. Research Paper Search - For academic and scientific information
+3. Wikipedia Search - For comprehensive background information and factual summaries
+4. Data Analysis - For analyzing data provided by the user
+
+Choose the most appropriate tool(s) based on the user's question:
+- Use Web Search for current events, recent developments, or general information
+- Use Research Paper Search for academic knowledge, scientific findings, or technical details
+- Use Wikipedia Search for conceptual explanations, definitions, historical context, or general facts
+- Use Data Analysis when the user provides data to be analyzed
+
+Always try to provide the most accurate and helpful information.
+When responding, cite your sources appropriately."""
+
+# Function to create the system message
+def create_system_message(domain):
+    return SystemMessage(content=system_prompt.format(domain=domain))
+
+# Create the graph
+def create_agent_graph(domain="general research"):
+    """
+    Create a LangGraph for the research agent using prebuilt components
+    """
+    # Initialize the graph with the state
+    workflow = StateGraph(AgentState)
+    
+    # Add system message with domain context
+    system_prompt_message = create_system_message(domain)
+    
+    # Agent node function
+    def agent_node(state: AgentState):
+        messages = state["messages"]
+        if len(messages) == 0 or not isinstance(messages[0], SystemMessage):
+            messages = [system_prompt_message] + messages
+        
+        # Create model and bind tools
+        model = ChatOpenAI(model="gpt-4o", temperature=0)
+        model_with_tools = model.bind_tools(tools)
+        
+        # Generate response with tools
+        return {"messages": [model_with_tools.invoke(messages)]}
+    
+    # Add nodes
+    workflow.add_node("agent", agent_node)
+    
+    # Use prebuilt ToolNode
+    tool_node = ToolNode(tools=tools)
+    workflow.add_node("tools", tool_node)
+    
+    # Add conditional edges using prebuilt tools_condition
+    workflow.add_conditional_edges(
+        "agent",
+        tools_condition,
+        {
+            "tools": "tools",
+            END: END
+        }
+    )
+    
+    # Add edge back to agent after tools execution
+    workflow.add_edge("tools", "agent")
+    
+    # Set the entry point
+    workflow.add_edge(START, "agent")
+    
+    # Compile the graph
+    return workflow.compile()
+
+# Function to run the agent
+def run_agent(user_input, domain="general research", messages=None):
+    """
+    Run the agent with a user input
+    """
+    # Create the graph
+    graph = create_agent_graph(domain)
+    
+    # Initialize messages if not provided
+    if messages is None:
+        messages = [HumanMessage(content=user_input)]
+    else:
+        messages.append(HumanMessage(content=user_input))
+    
+    # Run the graph
+    result = graph.invoke({"messages": messages})
+    
+    return result["messages"]
+
+if __name__ == "__main__":
+    # Test the agent
+    domain = "artificial intelligence"
+    query = "What are the latest developments in natural language processing?"
+    
+    messages = run_agent(query, domain)
+    for message in messages:
+        if isinstance(message, AIMessage):
+            print("AI:", message.content)
+        elif isinstance(message, HumanMessage):
+            print("Human:", message.content)
+        elif isinstance(message, ToolMessage):
+            print(f"Tool ({message.name}):", message.content[:100] + "..." if len(message.content) > 100 else message.content) 

src/research_agent/tools.py

@@ -0,0 +1,80 @@
+from langchain_community.tools.tavily_search import TavilySearchResults
+from langchain_community.tools.arxiv.tool import ArxivQueryRun
+from langchain_community.tools.wikipedia.tool import WikipediaQueryRun
+from langchain.tools import BaseTool
+from typing import Optional, Type, Any, List, Dict
+from pydantic import BaseModel, Field
+import json
+import pandas as pd
+import requests
+
+class WebSearchTool(BaseTool):
+    name: str = "web_search"
+    description: str = "Search the web for general information and current events. Use this for queries about recent developments or general topics."
+    
+    def _run(self, query: str) -> str:
+        tavily_tool = TavilySearchResults(max_results=3)
+        results = tavily_tool.invoke(query)
+        return json.dumps(results, indent=2)
+
+class ResearchPaperTool(BaseTool):
+    name: str = "research_paper_search"
+    description: str = "Search for academic research papers on a topic. Use this for scientific information and academic knowledge."
+    
+    def _run(self, query: str) -> str:
+        arxiv_tool = ArxivQueryRun()
+        results = arxiv_tool.invoke(query)
+        return results
+
+class WikipediaSearchTool(BaseTool):
+    name: str = "wikipedia_search"
+    description: str = "Search Wikipedia for comprehensive background information on a topic. Use this for factual summaries and foundational knowledge."
+    
+    def _run(self, query: str) -> str:
+        wikipedia_tool = WikipediaQueryRun(top_k_results=3)
+        results = wikipedia_tool.invoke(query)
+        return results
+
+class DataAnalysisInput(BaseModel):
+    data: str = Field(..., description="JSON or CSV formatted data to analyze")
+    analysis_type: str = Field(..., description="Type of analysis to perform (summary, trends, comparison)")
+    
+class DataAnalysisTool(BaseTool):
+    name: str = "data_analysis"
+    description: str = "Analyze data provided in JSON or CSV format. Can perform summary, trends, or comparison analysis."
+    args_schema: Type[BaseModel] = DataAnalysisInput
+    
+    def _run(self, data: str, analysis_type: str) -> str:
+        try:
+            # Try to parse as JSON
+            try:
+                parsed_data = json.loads(data)
+                df = pd.DataFrame(parsed_data)
+            except:
+                # Try as CSV
+                import io
+                df = pd.read_csv(io.StringIO(data))
+            
+            if analysis_type == "summary":
+                return f"Summary Statistics:\n{df.describe().to_string()}"
+            elif analysis_type == "trends":
+                if len(df.columns) >= 2:
+                    numeric_cols = df.select_dtypes(include=['number']).columns
+                    if len(numeric_cols) >= 2:
+                        return f"Correlation Analysis:\n{df[numeric_cols].corr().to_string()}"
+                    return "Not enough numeric columns for trend analysis"
+                return "Not enough columns for trend analysis"
+            elif analysis_type == "comparison":
+                return f"Column Comparison:\n{df.head(10).to_string()}"
+            else:
+                return f"Unknown analysis type: {analysis_type}"
+        except Exception as e:
+            return f"Error analyzing data: {str(e)}"
+
+def get_tools():
+    return [
+        WebSearchTool(),
+        ResearchPaperTool(),
+        WikipediaSearchTool(),
+        DataAnalysisTool()
+    ]