🤖 ContextAgent

A modular, production-ready AI assistant backend built with Python, LangChain, OpenAI API, and RAG (Retrieval-Augmented Generation) pipeline.

✨ Features

🔍 RAG Pipeline: Embed documents and perform similarity search for context retrieval
🤖 LangChain Agent: Chain of tools including Calculator and Google Search
💬 Conversational Memory: Maintains conversation history using LangChain's ConversationBufferMemory
🧾 Document Ingestion: Support for PDFs, TXT, Markdown, and DOCX files
🛠️ Embeddings: OpenAI embeddings for document vectorization
🗂️ Vector Store: ChromaDB for fast document retrieval
🔑 Environment-based Configuration: Secure API key management
📄 Swagger Documentation: Auto-generated API docs
🚀 FastAPI Backend: High-performance async API

🏗️ Architecture

ContextAgent/
├── app/
│   ├── main.py                # FastAPI app entrypoint
│   ├── routes/
│   │   ├── chat.py            # Chat endpoints
│   │   └── ingest.py          # Document upload endpoints
│   ├── chains/
│   │   ├── qa_chain.py        # RAG + LLM chain
│   │   └── agent_chain.py     # LangChain agent setup
│   ├── tools/
│   │   ├── calculator.py      # Custom LangChain tools
│   │   └── google_search.py   # Web search tool
│   ├── memory/
│   │   └── session_memory.py  # Conversational memory
│   ├── ingest/
│   │   ├── embedder.py        # Embedding function
│   │   └── vector_store.py    # ChromaDB setup
│   ├── utils/
│   │   ├── config.py          # Environment + settings
│   │   └── document_loader.py # Document processing
│   └── schemas/
│       └── request_model.py   # Pydantic schemas
├── .env.example               # Environment variables template
├── requirements.txt           # Python dependencies
└── README.md                 # This file

🚀 Quick Start

1. Clone and Setup

git clone git https://github.com:webcodelabb/ContextAgent.git
cd ContextAgent

2. Install Dependencies

pip install -r requirements.txt

3. Configure Environment

Copy the example environment file and add your API keys:

cp env.example .env

Edit .env and add your OpenAI API key:

OPENAI_API_KEY=your_openai_api_key_here
OPENAI_MODEL=gpt-4

4. Run the Application

python -m app.main

The server will start at http://localhost:8000

📚 API Documentation

Chat Endpoints

`POST /chat/`

Ask questions to the AI assistant.

Request Body:

{
  "question": "What does this PDF say about climate change?",
  "history": [
    {"role": "user", "content": "Summarize the document"},
    {"role": "agent", "content": "Sure, here's the summary..."}
  ],
  "use_rag": true,
  "use_agent": false
}

Response:

{
  "answer": "The PDF discusses the recent changes in global temperatures and the effects of greenhouse gases...",
  "sources": ["climate_report_2024.pdf"],
  "reasoning": null,
  "metadata": {
    "model": "gpt-4",
    "session_id": "default",
    "documents_retrieved": 3
  }
}

`GET /chat/memory/{session_id}`

Get conversation history for a session.

`DELETE /chat/memory/{session_id}`

Clear conversation memory for a session.

`GET /chat/tools`

Get information about available tools.

`GET /chat/stats`

Get statistics about the chat system.

Document Ingestion Endpoints

`POST /ingest/upload`

Upload a document for processing.

Supported formats: PDF, TXT, MD, DOCX

`POST /ingest/directory`

Ingest all supported documents from a directory.

`GET /ingest/stats`

Get statistics about ingested documents.

`DELETE /ingest/clear`

Clear all ingested documents.

Health Check

`GET /` or `GET /health`

Check system health and configuration.

🔧 Configuration

Environment Variables

Variable	Description	Default
`OPENAI_API_KEY`	OpenAI API key (required)	-
`OPENAI_MODEL`	OpenAI model to use	`gpt-4`
`VECTOR_STORE_TYPE`	Vector store type	`chroma`
`CHROMA_PERSIST_DIRECTORY`	ChromaDB storage path	`./chroma_db`
`HOST`	Server host	`0.0.0.0`
`PORT`	Server port	`8000`
`SERP_API_KEY`	SerpAPI key for web search	-
`LANGCHAIN_TRACING_V2`	Enable LangSmith tracing	`false`
`LANGCHAIN_API_KEY`	LangSmith API key	-

🛠️ Usage Examples

Python Client

import requests

# Chat with RAG
response = requests.post("http://localhost:8000/chat/", json={
    "question": "What are the main points in the uploaded documents?",
    "use_rag": True
})
print(response.json()["answer"])

# Chat with Agent
response = requests.post("http://localhost:8000/chat/", json={
    "question": "What's 15 * 23?",
    "use_agent": True
})
print(response.json()["answer"])

cURL Examples

# Simple chat
curl -X POST "http://localhost:8000/chat/" \
  -H "Content-Type: application/json" \
  -d '{"question": "Hello, how are you?"}'

# Upload document
curl -X POST "http://localhost:8000/ingest/upload" \
  -F "file=@document.pdf"

# Get system stats
curl "http://localhost:8000/chat/stats"

🧪 Testing

Manual Testing

Start the server: python -m app.main
Open Swagger docs: http://localhost:8000/docs
Test endpoints through the interactive interface

API Testing

# Health check
curl http://localhost:8000/health

# Upload a test document
curl -X POST "http://localhost:8000/ingest/upload" \
  -F "file=@test_document.pdf"

# Ask a question
curl -X POST "http://localhost:8000/chat/" \
  -H "Content-Type: application/json" \
  -d '{"question": "What is this document about?"}'

🔍 Features in Detail

RAG Pipeline

Document Ingestion: Upload PDFs, TXTs, MDs, DOCXs
Text Processing: Split documents into chunks
Embedding: Convert text to vectors using OpenAI
Storage: Store in ChromaDB vector database
Retrieval: Find relevant documents for queries
Generation: Generate answers using LLM with context

LangChain Agent

Calculator Tool: Perform mathematical calculations
Google Search Tool: Search the web for current information
Conversational Memory: Maintains chat history
Multi-step Reasoning: Chain multiple tools together

Document Processing

PDF: PyPDF2 for text extraction
TXT: UTF-8 text files
MD: Markdown files
DOCX: Microsoft Word documents
Chunking: Intelligent text splitting with overlap
Metadata: Preserves source information

🚀 Production Deployment

Docker (Recommended)

FROM python:3.11-slim

WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt

COPY . .
EXPOSE 8000

CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

Environment Setup

# Production environment
export OPENAI_API_KEY=your_production_key
export OPENAI_MODEL=gpt-4
export HOST=0.0.0.0
export PORT=8000

Security Considerations

Set up proper CORS configuration
Use environment variables for secrets
Implement authentication if needed
Monitor API usage and costs
Set up logging and monitoring

🤝 Contributing

Fork the repository
Create a feature branch
Make your changes
Add tests if applicable
Submit a pull request

📄 License

This project is licensed under the MIT License.

🙏 Acknowledgments

LangChain for the amazing LLM framework
OpenAI for the GPT models
ChromaDB for vector storage
FastAPI for the web framework

Built with ❤️ for the AI community Testing coauthor achievement Fixing coauthor format

webcodelabb/ContextAgent