initial commit to origin

.gitignore

@@ -0,0 +1,43 @@
+# 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.md 
+.chainlit/*
+
+**/.DS_Store
+.DS_Store

Dockerfile

@@ -0,0 +1,31 @@
+
+# Get a distribution that has uv already installed
+FROM ghcr.io/astral-sh/uv:python3.13-bookworm-slim
+
+# Add user - this is the user that will run the app
+# If you do not set user, the app will run as root (undesirable)
+RUN useradd -m -u 1000 user
+USER user
+
+# Set the home directory and path
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH        
+
+ENV UVICORN_WS_PROTOCOL=websockets
+
+
+# Set the working directory
+WORKDIR $HOME/app
+
+# Copy the app to the container
+COPY --chown=user . $HOME/app
+
+# Install the dependencies
+# RUN uv sync --frozen
+RUN uv sync
+
+# Expose the port
+EXPOSE 7860
+
+# Run the app
+CMD ["uv", "run", "chainlit", "run", "app.py", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,87 @@
+# Research Assistant
+
+A powerful research assistant that combines Wikipedia, Reddit, and Semantic Scholar using LangGraph and Chainlit.
+
+## Prerequisites
+
+- Python 3.9 or higher
+- `uv` package manager (install with `curl -LsSf https://astral.sh/uv/install.sh | sh`)
+
+## Setup
+
+1. Clone the repository:
+```bash
+git clone <repository-url>
+cd research-assistant
+```
+
+2. Create and activate virtual environment:
+```bash
+uv venv
+source .venv/bin/activate  # On Unix/macOS
+# or
+.venv\Scripts\activate  # On Windows
+```
+
+3. Install dependencies:
+```bash
+# Install all dependencies (including dev dependencies)
+uv sync --all
+
+# Or, install only production dependencies
+uv sync
+```
+
+4. Configure your environment:
+```bash
+# Copy the environment template
+cp .env.template .env
+
+# Edit .env with your API keys
+OPENAI_API_KEY=your_openai_api_key
+REDDIT_CLIENT_ID=your_reddit_client_id
+REDDIT_CLIENT_SECRET=your_reddit_client_secret
+```
+
+## Development
+
+The project uses modern Python development tools:
+- `ruff` for linting
+- `black` for code formatting
+- `mypy` for type checking
+
+To run the development tools:
+```bash
+# Format code
+black .
+
+# Lint code
+ruff check .
+
+# Type check
+mypy .
+```
+
+## Running the Application
+
+1. Activate the virtual environment (if not already activated):
+```bash
+source .venv/bin/activate  # On Unix/macOS
+# or
+.venv\Scripts\activate  # On Windows
+```
+
+2. Start the Chainlit app:
+```bash
+chainlit run app.py
+```
+
+The application will be available at `http://localhost:8000`
+
+## Project Structure
+
+- `app.py`: Main application with LangGraph implementation
+- `tools.py`: Tool implementations (Wikipedia, Reddit, Semantic Scholar)
+- `chainlit.md`: Chainlit welcome message
+- `pyproject.toml`: Project metadata and dependency specifications
+- `.env.template`: Template for environment variables 

app.py

@@ -0,0 +1,155 @@
+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 research_assistant.tools import tools
+
+
+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."""
+    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()
+
+
+@cl.on_chat_start
+async def start():
+    """Initialize the chat session."""
+    # Initialize session state
+    initial_state = AgentState(
+        messages=[SystemMessage(content="You are a helpful research assistant. Only answer the last question.")],
+    )
+
+    cl.user_session.set("state", initial_state)
+
+    await cl.Message(
+        content="""👋 Hello! I'm your research assistant. I can help you find information from:
+        
+- 📚 Wikipedia
+- 💬 Reddit discussions
+- 📖 Academic papers (Semantic Scholar)
+
+What would you like to know about?"""
+    ).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():
+
+            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}"
+                    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)}"
+                    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"
+                    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)
+
+
+#     except Exception as e:
+#         await cl.Message(
+#             content=f"""❌ An error occurred:
+# ```python
+# {str(e)}
+# ```"""
+#         ).send()

pyproject.toml

@@ -0,0 +1,46 @@
+[build-system]
+requires = ["setuptools>=69.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "research-assistant"
+version = "0.1.0"
+description = "A 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",
+]
+
+[project.optional-dependencies]
+dev = [
+    "ruff~=0.3.3",
+    "black~=24.2.0",
+    "mypy~=1.9.0",
+]
+
+[tool.setuptools]
+packages = ["research_assistant"]
+
+[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 

research_assistant/__init__.py

@@ -0,0 +1,5 @@
+"""Research Assistant package for information retrieval from multiple sources."""
+
+from .tools import tools
+
+__all__ = ["tools"]

research_assistant/tools.py

@@ -0,0 +1,27 @@
+from dotenv import load_dotenv
+import os
+
+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
+
+load_dotenv()
+
+wikipedia_tool = WikipediaQueryRun(api_wrapper=WikipediaAPIWrapper())
+semantic_scholar_tool = SemanticScholarQueryRun()
+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")
+    )
+)
+
+# Initialize tools
+tools = [
+    wikipedia_tool,
+    reddit_tool,
+    semantic_scholar_tool,
+]