From 6bb571088cdab1321c1228bf2f1c971583f37a2c Mon Sep 17 00:00:00 2001 From: alexsin368 Date: Mon, 2 Feb 2026 16:16:50 -0800 Subject: [PATCH 01/12] add sample_solutions folder Signed-off-by: alexsin368 Signed-off-by: gopal-raj-suresh --- sample_solutions/README.md | 1 + 1 file changed, 1 insertion(+) create mode 100644 sample_solutions/README.md diff --git a/sample_solutions/README.md b/sample_solutions/README.md new file mode 100644 index 00000000..43d98118 --- /dev/null +++ b/sample_solutions/README.md @@ -0,0 +1 @@ +# PLACEHOLDER \ No newline at end of file From 803ea9040e772ab3186c2f59270d378634ce2d67 Mon Sep 17 00:00:00 2001 From: gopal-raj-suresh Date: Tue, 3 Feb 2026 12:03:24 -0800 Subject: [PATCH 02/12] add MultiAgentQnA Signed-off-by: gopal-raj-suresh --- sample_solutions/MultiAgentQnA/.gitignore | 64 ++++ sample_solutions/MultiAgentQnA/QUICKSTART.md | 201 +++++++++++ sample_solutions/MultiAgentQnA/README.md | 316 +++++++++++++++++ .../MultiAgentQnA/TROUBLESHOOTING.md | 289 ++++++++++++++++ .../MultiAgentQnA/api/.env.example | 22 ++ sample_solutions/MultiAgentQnA/api/Dockerfile | 20 ++ .../MultiAgentQnA/api/__init__.py | 4 + sample_solutions/MultiAgentQnA/api/config.py | 36 ++ sample_solutions/MultiAgentQnA/api/models.py | 70 ++++ .../MultiAgentQnA/api/requirements.txt | 14 + sample_solutions/MultiAgentQnA/api/server.py | 290 ++++++++++++++++ .../MultiAgentQnA/api/services/__init__.py | 25 ++ .../MultiAgentQnA/api/services/agents.py | 303 +++++++++++++++++ .../MultiAgentQnA/api/services/api_client.py | 185 ++++++++++ .../MultiAgentQnA/api/services/rag_service.py | 293 ++++++++++++++++ .../MultiAgentQnA/docker-compose.yml | 40 +++ sample_solutions/MultiAgentQnA/images/ui.png | Bin 0 -> 254805 bytes sample_solutions/MultiAgentQnA/ui/Dockerfile | 20 ++ sample_solutions/MultiAgentQnA/ui/index.html | 14 + .../MultiAgentQnA/ui/package.json | 32 ++ .../MultiAgentQnA/ui/postcss.config.js | 7 + sample_solutions/MultiAgentQnA/ui/src/App.jsx | 30 ++ .../ui/src/components/ChatInterface.jsx | 320 ++++++++++++++++++ .../ui/src/components/Header.jsx | 53 +++ .../ui/src/components/LogsPanel.jsx | 134 ++++++++ .../ui/src/components/SettingsPage.jsx | 245 ++++++++++++++ .../MultiAgentQnA/ui/src/index.css | 26 ++ .../MultiAgentQnA/ui/src/main.jsx | 11 + .../MultiAgentQnA/ui/src/services/api.js | 132 ++++++++ .../MultiAgentQnA/ui/tailwind.config.js | 12 + .../MultiAgentQnA/ui/vite.config.js | 18 + 31 files changed, 3226 insertions(+) create mode 100644 sample_solutions/MultiAgentQnA/.gitignore create mode 100644 sample_solutions/MultiAgentQnA/QUICKSTART.md create mode 100644 sample_solutions/MultiAgentQnA/README.md create mode 100644 sample_solutions/MultiAgentQnA/TROUBLESHOOTING.md create mode 100644 sample_solutions/MultiAgentQnA/api/.env.example create mode 100644 sample_solutions/MultiAgentQnA/api/Dockerfile create mode 100644 sample_solutions/MultiAgentQnA/api/__init__.py create mode 100644 sample_solutions/MultiAgentQnA/api/config.py create mode 100644 sample_solutions/MultiAgentQnA/api/models.py create mode 100644 sample_solutions/MultiAgentQnA/api/requirements.txt create mode 100644 sample_solutions/MultiAgentQnA/api/server.py create mode 100644 sample_solutions/MultiAgentQnA/api/services/__init__.py create mode 100644 sample_solutions/MultiAgentQnA/api/services/agents.py create mode 100644 sample_solutions/MultiAgentQnA/api/services/api_client.py create mode 100644 sample_solutions/MultiAgentQnA/api/services/rag_service.py create mode 100644 sample_solutions/MultiAgentQnA/docker-compose.yml create mode 100644 sample_solutions/MultiAgentQnA/images/ui.png create mode 100644 sample_solutions/MultiAgentQnA/ui/Dockerfile create mode 100644 sample_solutions/MultiAgentQnA/ui/index.html create mode 100644 sample_solutions/MultiAgentQnA/ui/package.json create mode 100644 sample_solutions/MultiAgentQnA/ui/postcss.config.js create mode 100644 sample_solutions/MultiAgentQnA/ui/src/App.jsx create mode 100644 sample_solutions/MultiAgentQnA/ui/src/components/ChatInterface.jsx create mode 100644 sample_solutions/MultiAgentQnA/ui/src/components/Header.jsx create mode 100644 sample_solutions/MultiAgentQnA/ui/src/components/LogsPanel.jsx create mode 100644 sample_solutions/MultiAgentQnA/ui/src/components/SettingsPage.jsx create mode 100644 sample_solutions/MultiAgentQnA/ui/src/index.css create mode 100644 sample_solutions/MultiAgentQnA/ui/src/main.jsx create mode 100644 sample_solutions/MultiAgentQnA/ui/src/services/api.js create mode 100644 sample_solutions/MultiAgentQnA/ui/tailwind.config.js create mode 100644 sample_solutions/MultiAgentQnA/ui/vite.config.js diff --git a/sample_solutions/MultiAgentQnA/.gitignore b/sample_solutions/MultiAgentQnA/.gitignore new file mode 100644 index 00000000..0dffe088 --- /dev/null +++ b/sample_solutions/MultiAgentQnA/.gitignore @@ -0,0 +1,64 @@ +# Python +__pycache__/ +*.py[cod] +*$py.class +*.so +.Python +env/ +venv/ +ENV/ +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +*.egg-info/ +.installed.cfg +*.egg +*.log + +# Node +node_modules/ +npm-debug.log* +yarn-debug.log* +yarn-error.log* +.pnpm-debug.log* +package-lock.json +dist/ +.cache/ + +# Environment +.env +.env.local +.env.*.local + +# IDEs +.vscode/ +.idea/ +*.swp +*.swo +*~ + +# OS +.DS_Store +Thumbs.db + +# Build +build/ +*.so + +# Testing +.coverage +.pytest_cache/ +htmlcov/ + +# Application specific +rag_index/ + diff --git a/sample_solutions/MultiAgentQnA/QUICKSTART.md b/sample_solutions/MultiAgentQnA/QUICKSTART.md new file mode 100644 index 00000000..44fda48e --- /dev/null +++ b/sample_solutions/MultiAgentQnA/QUICKSTART.md @@ -0,0 +1,201 @@ +# Quick Start Guide + +Get up and running with the Multi-Agent Q&A application in 5 minutes! + +## Prerequisites + +- Docker and Docker Compose installed +- Valid enterprise-inference API credentials + +## Step-by-Step Setup + +### 1. Configure Environment Variables + +Create the API environment file: + +```bash +cd MultiAgentQnA +cp api/env.example api/.env +``` + +Edit `api/.env` with your credentials: + +```env +BASE_URL=https://your-enterprise-inference-url.com +KEYCLOAK_CLIENT_ID=your_client_id +KEYCLOAK_CLIENT_SECRET=your_client_secret +EMBEDDING_MODEL_ENDPOINT=bge-base-en-v1.5 +INFERENCE_MODEL_ENDPOINT=Llama-3.1-8B-Instruct +EMBEDDING_MODEL_NAME=bge-base-en-v1.5 +INFERENCE_MODEL_NAME=meta-llama/Llama-3.1-8B-Instruct +``` + +### 2. Start with Docker Compose + +```bash +cd MultiAgentQnA +docker-compose up --build +``` + +Wait for both services to start: +- Backend API on http://localhost:5001 +- Frontend UI on http://localhost:3000 + +### 3. Access the Application + +Open your browser and navigate to: + +``` +http://localhost:3000 +``` + +You should see the Multi-Agent Q&A interface! + +## Alternative: Local Development + +### Backend + +```bash +cd MultiAgentQnA/api + +# Create virtual environment (recommended) +python -m venv venv +source venv/bin/activate # On Windows: venv\Scripts\activate + +# Install dependencies +pip install -r requirements.txt + +# Run the server +uvicorn server:app --reload --host 0.0.0.0 --port 5001 +``` + +### Frontend + +```bash +cd MultiAgentQnA/ui + +# Install dependencies +npm install + +# Run development server +npm run dev +``` + +## Testing the Application + +### Test the Chat Interface + +1. Navigate to the Chat page +2. Type a question, for example: + - **Code**: "How do I create a Python function?" + - **RAG**: "Find information about machine learning" + - **General**: "What is the weather like?" + +3. The system will automatically route your question to the appropriate agent + +### Test the Settings + +1. Click on "Settings" in the header +2. Modify agent configurations: + - Change roles, goals, or backstories + - Adjust max iterations + - Toggle verbose mode +3. Click "Save Configuration" +4. Test with new questions + +## Verify Everything Works + +### Check API Health + +```bash +curl http://localhost:5001/health +``` + +Expected response: +```json +{ + "status": "healthy", + "api_configured": true +} +``` + +### Test Chat Endpoint + +```bash +curl -X POST http://localhost:5001/chat \ + -H "Content-Type: application/json" \ + -d '{"message": "Hello!"}' +``` + +Expected response: +```json +{ + "response": "Response from agent...", + "agent": "normal_agent" +} +``` + +## Common First-Time Issues + +### Port Already in Use + +**Error**: `Address already in use` + +**Solution**: +```bash +# Find and kill process on port 5001 +lsof -ti:5001 | xargs kill -9 + +# Find and kill process on port 3000 +lsof -ti:3000 | xargs kill -9 + +# Or change ports in docker-compose.yml +``` + +### Cannot Connect to Enterprise API + +**Error**: `Authentication failed` + +**Solution**: +1. Double-check your `.env` credentials +2. Verify BASE_URL is correct +3. Ensure network access to enterprise-inference API + +### UI Shows "Failed to get response" + +**Solution**: +1. Check backend logs: `docker logs multiagent-qna-backend` +2. Verify API is running: `curl http://localhost:5001/health` +3. Check browser console for errors + +## Next Steps + +- Read the [README.md](README.md) for detailed documentation +- Check [TROUBLESHOOTING.md](TROUBLESHOOTING.md) for more help +- Customize agent configurations in the Settings page +- Integrate with your own knowledge bases or APIs + +## Architecture Overview + +``` +User Query + ↓ +Orchestration Agent (routes to appropriate specialist) + ↓ +┌─────────────────────────────────────────┐ +│ │ +├─ Code Agent ─── For programming Q&A │ +├─ RAG Agent ──── For document retrieval │ +└─ Normal Agent ── For general questions │ +``` + +The system automatically detects query type and routes to the best agent! + +## Need Help? + +- Check logs: `docker logs multiagent-qna-backend` +- Review [TROUBLESHOOTING.md](TROUBLESHOOTING.md) +- Verify environment variables are set correctly + +Happy chatting! 🚀 + diff --git a/sample_solutions/MultiAgentQnA/README.md b/sample_solutions/MultiAgentQnA/README.md new file mode 100644 index 00000000..33550928 --- /dev/null +++ b/sample_solutions/MultiAgentQnA/README.md @@ -0,0 +1,316 @@ +## Multi-Agent Q&A Application + +A sophisticated multi-agent Q&A application featuring intelligent task delegation to specialized agents with enterprise inference integration. + +## Table of Contents + +- [Project Overview](#project-overview) +- [Features](#features) +- [Architecture](#architecture) +- [Prerequisites](#prerequisites) +- [Quick Start Deployment](#quick-start-deployment) +- [User Interface](#user-interface) +- [Troubleshooting](#troubleshooting) +- [Additional Info](#additional-info) + +--- +## Project Overview + +The multiagent-qna project is a sophisticated Question & Answer application built on a multi-agent architecture. Its core function is to receive a user's query, intelligently determine the nature of the question, and delegate it to the most suitable specialized agent for generating a high-quality response. The system is designed for enterprise environments, integrating with enterprise-grade inference APIs for its language model interactions. + +--- + +## Features + +- **Multi-Agent Architecture**: Orchestration agent that intelligently routes queries to specialized agents +- **Specialized Agents**: + - **Code Agent**: Handles code-related questions and programming queries + - **RAG Agent**: Retrieves and answers questions from documents + - **Normal Agent**: Handles general questions and conversations +- **Modern UI**: ChatGPT-like interface with settings management +- **Enterprise Integration**: Uses enterprise-inference API for LLM interactions +- **Configurable**: Easily configure agent roles, goals, and behavior via UI + +--- + +## Architecture + +Below is the multi-agent system architecture showing how user queries are intelligently routed to specialized agents. The orchestration layer analyzes incoming queries using keyword detection and delegates them to the appropriate agent (Code, RAG, or Normal) for processing, ensuring each query is handled by the most qualified specialist. + +```mermaid +graph TD + A[User Interface] -->|Query| B[FastAPI Backend] + B --> C[Orchestration Logic] + C -->|Keyword Analysis| D{Agent Router} + + D -->|Code Keywords| E[Code Agent] + D -->|RAG Keywords| F[RAG Agent] + D -->|Default| G[Normal Agent] + + F -->|Search| H[FAISS Vector Store] + H -->|Context| F + + E -->|Prompt + Role| I[LLM API] + F -->|Prompt + Role + Context| I + G -->|Prompt + Role| I + + I -->|Response| B + B -->|Answer| A + + J[PDF Upload] -->|Documents| H + + style C fill:#e1f5ff + style D fill:#fff4e1 + style E fill:#ffe1e1 + style F fill:#e1ffe1 + style G fill:#f0e1ff + style I fill:#ffebe1 +``` + +The application consists of: +1. **Orchestration Agent**: Analyzes user queries and delegates to appropriate specialized agents +2. **Specialized Agents**: Each handles a specific domain (code, RAG, general) +3. **API Layer**: FastAPI backend with enterprise-inference integration +4. **UI**: React-based chat interface with settings management + +**Service Components:** + +1. **React Web UI (Port 3000)** - Provides ChatGPT-like interface with settings management for configuring agent roles, goals, and behavior + +2. **FastAPI Backend (Port 5001)** - Orchestrates multi-agent system, analyzes queries using keyword detection, delegates to specialized agents (Code, RAG, Normal), and manages FAISS vector store for document retrieval + +**Typical Flow:** + +1. User submits a query through the chat interface. +2. The FastAPI backend receives the query and passes it to the orchestration logic. +3. The orchestration logic analyzes the query using keyword detection to determine intent. +4. The agent router delegates the query to the appropriate specialized agent: + - **Code-related queries** (keywords: code, function, debug, etc.) → Code Agent + - **Document-based queries** (keywords: document, PDF, search, etc.) → RAG Agent + - **General queries** → Normal Agent +5. If RAG Agent is selected: + - Searches the FAISS vector store for relevant document context + - Retrieves matching chunks to augment the prompt +6. The selected agent constructs a specialized prompt with its role, goal, and context. +7. The agent calls the enterprise LLM API with the pre-configured token and specialized prompt. +8. The LLM generates a response tailored to the agent's expertise. +9. The response is returned to the user via the UI with agent attribution showing which specialist handled the query. + +--- + +## Prerequisites + +### System Requirements + +Before you begin, ensure you have the following installed: + +- **Docker and Docker Compose** +- **Enterprise inference endpoint access** (token-based authentication) + +### Required API Configuration + +**For Inference Service:** + +This application supports multiple inference deployment patterns: + +- **GenAI Gateway**: Provide your GenAI Gateway URL and API key +- **APISIX Gateway**: Provide your APISIX Gateway URL and authentication token + +Configuration requirements: +- INFERENCE_API_ENDPOINT: URL to your inference service (GenAI Gateway, APISIX Gateway, etc.) +- INFERENCE_API_TOKEN: Authentication token/API key for your chosen service + +### Local Development Configuration + +**For Local Testing Only (Optional)** + +If you're testing with a local inference endpoint using a custom domain (e.g., `inference.example.com` mapped to localhost in your hosts file): + +1. Edit `api/.env` and set: + ```bash + LOCAL_URL_ENDPOINT=inference.example.com + ``` + (Use the domain name from your INFERENCE_API_ENDPOINT without `https://`) + +2. This allows Docker containers to resolve your local domain correctly. + +**Note:** For public domains or cloud-hosted endpoints, leave the default value `not-needed`. + +### Verify Docker Installation + +```bash +# Check Docker version +docker --version + +# Check Docker Compose version +docker compose version + +# Verify Docker is running +docker ps +``` +--- + +## Quick Start Deployment + +### Clone the Repository + +```bash +git clone https://github.com/opea-project/Enterprise-Inference.git +cd Enterprise-Inference/sample_solutions/MultiAgentQnA +``` + +### Set up the Environment + +This application requires **two `.env` files** for proper configuration: + +1. **Root `.env` file** (for Docker Compose variables) +2. **`api/.env` file** (for backend application configuration) + +#### Step 1: Create Root `.env` File + +```bash +# From the MultiAgentQnA directory +cat > .env << EOF +# Docker Compose Configuration +LOCAL_URL_ENDPOINT=not-needed +EOF +``` + +**Note:** If using a local domain (e.g., `inference.example.com` mapped to localhost), replace `not-needed` with your domain name (without `https://`). + +#### Step 2: Create `api/.env` File + +You can either copy from the example file: + +```bash +cp api/.env.example api/.env +``` + +Then edit `api/.env` with your actual credentials, **OR** create it directly: + +```bash +cat > api/.env << EOF +# Inference API Configuration +# INFERENCE_API_ENDPOINT: URL to your inference service (without /v1 suffix) +# - For GenAI Gateway: https://genai-gateway.example.com +# - For APISIX Gateway: https://apisix-gateway.example.com/inference +INFERENCE_API_ENDPOINT=https://your-actual-api-endpoint.com +INFERENCE_API_TOKEN=your-actual-token-here + +# Model Configuration +# IMPORTANT: Use the full model names as they appear in your inference service +# Check available models: curl https://your-api-endpoint.com/v1/models -H "Authorization: Bearer your-token" +EMBEDDING_MODEL_NAME=BAAI/bge-base-en-v1.5 +INFERENCE_MODEL_NAME=meta-llama/Llama-3.1-8B-Instruct + +# Local URL Endpoint (for Docker) +LOCAL_URL_ENDPOINT=not-needed +EOF +``` + +**Important Configuration Notes:** + +- **INFERENCE_API_ENDPOINT**: Your actual inference service URL (replace `https://your-actual-api-endpoint.com`) +- **INFERENCE_API_TOKEN**: Your actual pre-generated authentication token +- **EMBEDDING_MODEL_NAME** and **INFERENCE_MODEL_NAME**: Use the exact model names from your inference service + - To check available models: `curl https://your-api-endpoint.com/v1/models -H "Authorization: Bearer your-token"` +- **LOCAL_URL_ENDPOINT**: Only needed if using local domain mapping + +**Note**: The docker-compose.yml file automatically loads environment variables from both `.env` (root) and `./api/.env` (backend) files. + +### Running the Application + +Start both API and UI services together with Docker Compose: + +```bash +# From the MultiAgentQnA directory +docker compose up --build + +# Or run in detached mode (background) +docker compose up -d --build +``` + +The API will be available at: `http://localhost:5001` +The UI will be available at: `http://localhost:3000` + +**View logs**: + +```bash +# All services +docker compose logs -f + +# Backend only +docker compose logs -f backend + +# Frontend only +docker compose logs -f frontend +``` + +**Verify the services are running**: + +```bash +# Check API health +curl http://localhost:5001/health + +# Check if containers are running +docker compose ps +``` +--- + +## User Interface + +**Using the Application** + +Make sure you are at the `http://localhost:3000` URL + +You will be directed to the main page which has each feature + +![User Interface](images/ui.png) + +### Chat Interface + +1. Navigate to the chat interface +2. Type your question in the input box +3. The orchestration agent will analyze your query and route it to the appropriate specialized agent +4. View the response with agent attribution + +### Settings Page + +Configure agents: +- **Orchestration Agent**: Role, goal, and backstory +- **Code Agent**: Code-specific configuration +- **RAG Agent**: Document retrieval settings +- **Normal Agent**: General conversation settings + +**UI Configuration** + +When running with Docker Compose, the UI automatically connects to the backend API. The frontend is available at `http://localhost:3000` and the API at `http://localhost:5001`. + +For production deployments, you may want to configure a reverse proxy or update the API URL in the frontend configuration. + +### Stopping the Application + + +```bash +docker compose down +``` + +--- + +## Troubleshooting + +For comprehensive troubleshooting guidance, common issues, and solutions, refer to: + +[TROUBLESHOOTING.md](TROUBLESHOOTING.md) + +--- + +## Additional Info + +The following models have been validated with MultiAgentQnA: + +| Model | Hardware | +|-------|----------| +| **meta-llama/Llama-3.1-8B-Instruct** | Gaudi | +| **Qwen/Qwen3-4B-Instruct-2507** | Xeon | +| **BAAI/bge-base-en-v1.5** (embeddings) | Gaudi | diff --git a/sample_solutions/MultiAgentQnA/TROUBLESHOOTING.md b/sample_solutions/MultiAgentQnA/TROUBLESHOOTING.md new file mode 100644 index 00000000..2d650032 --- /dev/null +++ b/sample_solutions/MultiAgentQnA/TROUBLESHOOTING.md @@ -0,0 +1,289 @@ +# Troubleshooting Guide + +This document addresses common issues you may encounter when running the Multi-Agent Q&A application. + +## Table of Contents + +1. [Environment Setup](#environment-setup) +2. [API Issues](#api-issues) +3. [UI Issues](#ui-issues) +4. [Agent Issues](#agent-issues) +5. [Docker Issues](#docker-issues) + +--- + +## Environment Setup + +### Issue: Missing environment variables + +**Symptoms:** +- API fails to start +- Authentication errors +- "Configuration error" messages + +**Solution:** +1. Ensure you have created `api/.env` file based on `api/env.example` +2. Verify all required variables are set: + ```bash + BASE_URL=https://your-api-url.com + KEYCLOAK_CLIENT_ID=your_client_id + KEYCLOAK_CLIENT_SECRET=your_client_secret + ``` +3. Check that the `.env` file is in the `api/` directory + +### Issue: Python dependencies not installing + +**Symptoms:** +- Import errors +- "Module not found" errors + +**Solution:** +```bash +cd api +pip install -r requirements.txt +``` + +--- + +## API Issues + +### Issue: Authentication fails + +**Symptoms:** +- "Authentication failed" errors +- 401 Unauthorized responses + +**Solution:** +1. Verify your `KEYCLOAK_CLIENT_SECRET` is correct +2. Check that `BASE_URL` points to the correct endpoint +3. Ensure network connectivity to the enterprise-inference API +4. Verify SSL certificate issues by checking if `verify=False` is needed in api_client.py + +### Issue: API returns empty responses + +**Symptoms:** +- No content in chat responses +- "Unexpected response structure" errors + +**Solution:** +1. Check the model endpoints in `.env`: + ```bash + EMBEDDING_MODEL_ENDPOINT=bge-base-en-v1.5 + INFERENCE_MODEL_ENDPOINT=Llama-3.1-8B-Instruct + ``` +2. Verify the inference API is returning valid responses +3. Check API logs for detailed error messages + +### Issue: API is slow to respond + +**Symptoms:** +- Long wait times for responses +- Timeout errors + +**Solution:** +1. Reduce `max_tokens` in agent configurations +2. Set `max_iter` to a lower value (e.g., 5-10 instead of 15) +3. Check network latency to enterprise-inference API + +--- + +## UI Issues + +### Issue: Cannot connect to API + +**Symptoms:** +- "Failed to get response" errors +- Network errors in browser console + +**Solution:** +1. Verify backend is running on port 5001: + ```bash + curl http://localhost:5001/health + ``` +2. Check Vite proxy configuration in `ui/vite.config.js` +3. Ensure CORS is properly configured in `api/server.py` + +### Issue: Page doesn't load + +**Symptoms:** +- Blank page +- JavaScript errors in console + +**Solution:** +1. Install dependencies: + ```bash + cd ui + npm install + ``` +2. Clear browser cache and reload +3. Check for console errors in browser DevTools + +--- + +## Agent Issues + +### Issue: Wrong agent is selected + +**Symptoms:** +- Code questions routed to general agent +- RAG questions not using retrieval + +**Solution:** +1. The routing is based on keyword detection in `agents.py` +2. Review `determine_agent_type()` function +3. Add custom keywords to improve routing accuracy + +### Issue: Agent configuration not saved + +**Symptoms:** +- Settings revert after saving +- Default configuration persists + +**Solution:** +1. Check browser console for API errors +2. Verify `/config` POST endpoint is working: + ```bash + curl -X POST http://localhost:5001/config \ + -H "Content-Type: application/json" \ + -d '{"orchestration": {"role": "Test"}}' + ``` + +--- + +## Docker Issues + +### Issue: Containers won't start + +**Symptoms:** +- `docker-compose up` fails +- Port already in use errors + +**Solution:** +1. Stop existing containers: + ```bash + docker-compose down + ``` +2. Check for port conflicts: + ```bash + # Check if ports are in use + lsof -i :5001 # API + lsof -i :3000 # UI + ``` +3. Rebuild containers: + ```bash + docker-compose up --build + ``` + +### Issue: Environment variables not loading + +**Symptoms:** +- Configuration defaults being used +- Authentication errors in containers + +**Solution:** +1. Ensure `.env` file exists in `api/` directory +2. Check docker-compose.yml references the env_file correctly: + ```yaml + env_file: + - ./api/.env + ``` +3. Restart containers after creating `.env`: + ```bash + docker-compose restart backend + ``` + +### Issue: Volume mounting not working + +**Symptoms:** +- Code changes not reflecting in containers +- Hot reload not working + +**Solution:** +1. Verify volume mounts in docker-compose.yml: + ```yaml + volumes: + - ./api:/app + ``` +2. Check file permissions +3. Restart containers after configuration changes + +--- + +## General Debugging Tips + +### Check Logs + +**Backend:** +```bash +# Docker +docker logs multiagent-qna-backend + +# Local +tail -f api/logs/app.log +``` + +**Frontend:** +```bash +# Docker +docker logs multiagent-qna-frontend + +# Local - check browser DevTools console +``` + +### Test API Endpoints + +```bash +# Health check +curl http://localhost:5001/health + +# Configuration +curl http://localhost:5001/config + +# Chat +curl -X POST http://localhost:5001/chat \ + -H "Content-Type: application/json" \ + -d '{"message": "Hello!"}' +``` + +### Common Python Debugging + +```python +# Add verbose logging +import logging +logging.basicConfig(level=logging.DEBUG) + +# Check agent configuration +from services.agents import get_code_agent +agent = get_code_agent() +print(agent.role, agent.goal) +``` + +--- + +## Performance Optimization + +1. **Reduce Token Usage:** + - Lower `max_tokens` in API calls + - Reduce `max_iter` for agents + - Use caching where possible + +2. **Optimize Agent Routing:** + - Fine-tune keyword detection + - Consider using more sophisticated classification + +3. **Batch Processing:** + - Process multiple queries in parallel + - Use connection pooling for API calls + +--- + +## Still Having Issues? + +1. Check the [README.md](README.md) for setup instructions +2. Review error logs in detail +3. Verify all prerequisites are met +4. Ensure network connectivity to enterprise-inference API +5. Test API endpoints independently + +For additional help, please check the project documentation or contact support. + diff --git a/sample_solutions/MultiAgentQnA/api/.env.example b/sample_solutions/MultiAgentQnA/api/.env.example new file mode 100644 index 00000000..b632f681 --- /dev/null +++ b/sample_solutions/MultiAgentQnA/api/.env.example @@ -0,0 +1,22 @@ +# Inference API Configuration +# INFERENCE_API_ENDPOINT: URL to your inference service (without /v1 suffix) +# - For GenAI Gateway: https://genai-gateway.example.com +# - For APISIX Gateway: https://apisix-gateway.example.com/inference +# +# INFERENCE_API_TOKEN: Authentication token/API key for the inference service +# - For GenAI Gateway: Your GenAI Gateway API key +# - For APISIX Gateway: Your APISIX authentication token +INFERENCE_API_ENDPOINT=https://api.example.com +INFERENCE_API_TOKEN=your-pre-generated-token-here + +# Model Configuration +# IMPORTANT: Use the full model names as they appear in your inference service +# Check available models: curl https://your-api-endpoint.com/v1/models -H "Authorization: Bearer your-token" +EMBEDDING_MODEL_NAME=BAAI/bge-base-en-v1.5 +INFERENCE_MODEL_NAME=meta-llama/Llama-3.1-8B-Instruct + +# Local URL Endpoint (only needed for non-public domains) +# If using a local domain like inference.example.com mapped to localhost: +# Set this to: inference.example.com (domain without https://) +# If using a public domain, set any placeholder value like: not-needed +LOCAL_URL_ENDPOINT=not-needed diff --git a/sample_solutions/MultiAgentQnA/api/Dockerfile b/sample_solutions/MultiAgentQnA/api/Dockerfile new file mode 100644 index 00000000..e957a3ba --- /dev/null +++ b/sample_solutions/MultiAgentQnA/api/Dockerfile @@ -0,0 +1,20 @@ +FROM python:3.10-slim + +# Set the working directory in the container +WORKDIR /app + +# Copy requirements file +COPY requirements.txt . + +# Install Python dependencies +RUN pip install --no-cache-dir -r requirements.txt + +# Copy the rest of the application files into the container +COPY . . + +# Expose the port the service runs on +EXPOSE 5001 + +# Command to run the application +CMD ["uvicorn", "server:app", "--host", "0.0.0.0", "--port", "5001", "--reload"] + diff --git a/sample_solutions/MultiAgentQnA/api/__init__.py b/sample_solutions/MultiAgentQnA/api/__init__.py new file mode 100644 index 00000000..25f9058b --- /dev/null +++ b/sample_solutions/MultiAgentQnA/api/__init__.py @@ -0,0 +1,4 @@ +""" +Multi-Agent Q&A API +""" + diff --git a/sample_solutions/MultiAgentQnA/api/config.py b/sample_solutions/MultiAgentQnA/api/config.py new file mode 100644 index 00000000..8d48da0b --- /dev/null +++ b/sample_solutions/MultiAgentQnA/api/config.py @@ -0,0 +1,36 @@ +""" +Configuration settings for Multi-Agent Q&A API +""" + +import os +from dotenv import load_dotenv + +# Load environment variables from .env file +load_dotenv() + +# Inference API Configuration +# Supports multiple inference deployment patterns: +# - GenAI Gateway: Provide your GenAI Gateway URL and API key +# - APISIX Gateway: Provide your APISIX Gateway URL and authentication token +INFERENCE_API_ENDPOINT = os.getenv("INFERENCE_API_ENDPOINT", "https://api.example.com") +INFERENCE_API_TOKEN = os.getenv("INFERENCE_API_TOKEN") + +# Model Configuration +EMBEDDING_MODEL_NAME = os.getenv("EMBEDDING_MODEL_NAME", "bge-base-en-v1.5") +INFERENCE_MODEL_NAME = os.getenv("INFERENCE_MODEL_NAME", "meta-llama/Llama-3.1-8B-Instruct") + +# Validate required configuration +if not INFERENCE_API_ENDPOINT or not INFERENCE_API_TOKEN: + raise ValueError("INFERENCE_API_ENDPOINT and INFERENCE_API_TOKEN must be set in environment variables") + +# Application Settings +APP_TITLE = "Multi-Agent Q&A" +APP_DESCRIPTION = "A multi-agent Q&A system using CrewAI" +APP_VERSION = "1.0.0" + +# CORS Settings +CORS_ALLOW_ORIGINS = ["*"] # Update with specific origins in production +CORS_ALLOW_CREDENTIALS = True +CORS_ALLOW_METHODS = ["*"] +CORS_ALLOW_HEADERS = ["*"] + diff --git a/sample_solutions/MultiAgentQnA/api/models.py b/sample_solutions/MultiAgentQnA/api/models.py new file mode 100644 index 00000000..94a7f3e6 --- /dev/null +++ b/sample_solutions/MultiAgentQnA/api/models.py @@ -0,0 +1,70 @@ +""" +Pydantic models for request/response validation +""" + +from pydantic import BaseModel, Field +from typing import Optional, Dict, Any + + +class ChatMessage(BaseModel): + """Individual chat message""" + role: str = Field(..., description="Message role (user or assistant)") + content: str = Field(..., description="Message content") + agent: Optional[str] = Field(None, description="Agent that generated the response") + + +class ChatRequest(BaseModel): + """Request model for chat messages""" + message: str = Field(..., min_length=1, description="User message") + agent_config: Optional[Dict[str, Any]] = Field(None, description="Optional agent configuration") + + class Config: + json_schema_extra = { + "example": { + "message": "How do I implement a recursive function in Python?", + "agent_config": None + } + } + + +class ChatResponse(BaseModel): + """Response model for chat messages""" + response: str = Field(..., description="Agent response") + agent: str = Field(..., description="Agent that generated the response") + + class Config: + json_schema_extra = { + "example": { + "response": "A recursive function calls itself...", + "agent": "code_agent" + } + } + + +class AgentConfig(BaseModel): + """Configuration for a single agent""" + role: str = Field(..., description="Agent role") + goal: str = Field(..., description="Agent goal") + backstory: str = Field(..., description="Agent backstory") + max_iter: Optional[int] = Field(15, description="Maximum iterations") + verbose: Optional[bool] = Field(True, description="Verbose output") + + +class AgentConfigs(BaseModel): + """Configuration for all agents""" + orchestration: Optional[AgentConfig] = None + code: Optional[AgentConfig] = None + rag: Optional[AgentConfig] = None + normal: Optional[AgentConfig] = None + + +class HealthResponse(BaseModel): + """Response model for health check""" + status: str = Field(..., description="Health status") + api_configured: bool = Field(..., description="Whether API is configured") + + +class ConfigResponse(BaseModel): + """Response model for configuration""" + config: Dict[str, Any] = Field(..., description="Current agent configuration") + diff --git a/sample_solutions/MultiAgentQnA/api/requirements.txt b/sample_solutions/MultiAgentQnA/api/requirements.txt new file mode 100644 index 00000000..6b51bd92 --- /dev/null +++ b/sample_solutions/MultiAgentQnA/api/requirements.txt @@ -0,0 +1,14 @@ +fastapi>=0.109.0 +uvicorn[standard]>=0.27.0 +python-dotenv>=1.0.0 +openai>=1.10.0 +python-multipart>=0.0.22 +pydantic>=2.5.0 +pydantic-settings>=2.1.0 +cryptography>=3.1.0 +httpx>=0.24.0 +requests>=2.32.0 +pypdf>=4.0.0 +faiss-cpu>=1.7.4 +numpy>=1.24.0 + diff --git a/sample_solutions/MultiAgentQnA/api/server.py b/sample_solutions/MultiAgentQnA/api/server.py new file mode 100644 index 00000000..2a7fc0db --- /dev/null +++ b/sample_solutions/MultiAgentQnA/api/server.py @@ -0,0 +1,290 @@ +""" +FastAPI server with routes for Multi-Agent Q&A API +""" + +import logging +import os +import tempfile +from contextlib import asynccontextmanager +from fastapi import FastAPI, HTTPException, status, UploadFile, File +from fastapi.middleware.cors import CORSMiddleware + +import config +from models import ( + ChatRequest, ChatResponse, HealthResponse, + AgentConfigs, ConfigResponse +) +from services import process_query, update_agent_configs +from services.rag_service import get_rag_service + +# Configure logging +logging.basicConfig( + level=logging.INFO, + format='%(asctime)s - %(name)s - %(levelname)s - %(message)s' +) +logger = logging.getLogger(__name__) + +# In-memory log store for agent activity +agent_activity_logs = [] + + +@asynccontextmanager +async def lifespan(app: FastAPI): + """Lifespan context manager for FastAPI app""" + # Startup + logger.info("Initializing Multi-Agent Q&A API") + + yield + + # Shutdown + logger.info("Shutting down Multi-Agent Q&A API") + + +# Initialize FastAPI app +app = FastAPI( + title=config.APP_TITLE, + description=config.APP_DESCRIPTION, + version=config.APP_VERSION, + lifespan=lifespan +) + +# Add CORS middleware +app.add_middleware( + CORSMiddleware, + allow_origins=config.CORS_ALLOW_ORIGINS, + allow_credentials=config.CORS_ALLOW_CREDENTIALS, + allow_methods=config.CORS_ALLOW_METHODS, + allow_headers=config.CORS_ALLOW_HEADERS, +) + + +# ==================== Routes ==================== + +@app.get("/") +def root(): + """Health check endpoint""" + return { + "message": "Multi-Agent Q&A API is running", + "version": config.APP_VERSION, + "status": "healthy" + } + + +@app.get("/health", response_model=HealthResponse) +def health_check(): + """Detailed health check""" + api_configured = bool(config.INFERENCE_API_TOKEN) + return HealthResponse( + status="healthy", + api_configured=api_configured + ) + + +@app.post("/chat", response_model=ChatResponse) +def chat_endpoint(request: ChatRequest): + """ + Process a chat message using the multi-agent system + + - **message**: User message/query + - **agent_config**: Optional agent configuration override + """ + if not request.message or not request.message.strip(): + raise HTTPException( + status_code=status.HTTP_400_BAD_REQUEST, + detail="Message cannot be empty" + ) + + try: + # Process the query with the appropriate agent + response, agent = process_query( + query=request.message, + agent_config=request.agent_config + ) + + return ChatResponse( + response=response, + agent=agent + ) + + except Exception as e: + logger.error(f"Error processing query: {str(e)}", exc_info=True) + raise HTTPException( + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + detail=f"Error processing query: {str(e)}" + ) + + +@app.get("/config", response_model=ConfigResponse) +def get_config(): + """Get current agent configuration""" + from services.agents import ( + DEFAULT_ORCHESTRATION_CONFIG, + DEFAULT_CODE_CONFIG, + DEFAULT_RAG_CONFIG, + DEFAULT_NORMAL_CONFIG + ) + + return ConfigResponse( + config={ + "orchestration": DEFAULT_ORCHESTRATION_CONFIG, + "code": DEFAULT_CODE_CONFIG, + "rag": DEFAULT_RAG_CONFIG, + "normal": DEFAULT_NORMAL_CONFIG + } + ) + + +@app.post("/config") +def update_config(configs: AgentConfigs): + """Update agent configurations""" + try: + config_dict = {} + + if configs.orchestration: + config_dict["orchestration"] = { + "role": configs.orchestration.role, + "goal": configs.orchestration.goal, + "backstory": configs.orchestration.backstory, + "max_iter": configs.orchestration.max_iter, + "verbose": configs.orchestration.verbose + } + + if configs.code: + config_dict["code"] = { + "role": configs.code.role, + "goal": configs.code.goal, + "backstory": configs.code.backstory, + "max_iter": configs.code.max_iter, + "verbose": configs.code.verbose + } + + if configs.rag: + config_dict["rag"] = { + "role": configs.rag.role, + "goal": configs.rag.goal, + "backstory": configs.rag.backstory, + "max_iter": configs.rag.max_iter, + "verbose": configs.rag.verbose + } + + if configs.normal: + config_dict["normal"] = { + "role": configs.normal.role, + "goal": configs.normal.goal, + "backstory": configs.normal.backstory, + "max_iter": configs.normal.max_iter, + "verbose": configs.normal.verbose + } + + update_agent_configs(config_dict) + + return {"message": "Configuration updated successfully", "status": "success"} + + except Exception as e: + logger.error(f"Error updating configuration: {str(e)}") + raise HTTPException( + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + detail=f"Error updating configuration: {str(e)}" + ) + + +@app.get("/logs") +def get_logs(): + """Get agent activity logs""" + from services.agents import activity_logs + + # Return last 100 logs + return { + "logs": activity_logs[-100:], + "total": len(activity_logs) + } + + +@app.post("/rag/upload") +def upload_pdf(file: UploadFile = File(...)): + """ + Upload a PDF file and build RAG index + + - **file**: PDF file to upload and index + """ + if not file.filename.endswith('.pdf'): + raise HTTPException( + status_code=status.HTTP_400_BAD_REQUEST, + detail="Only PDF files are supported" + ) + + try: + # Save uploaded file temporarily + with tempfile.NamedTemporaryFile(delete=False, suffix='.pdf') as tmp_file: + content = file.file.read() + tmp_file.write(content) + tmp_path = tmp_file.name + + try: + # Process PDF + rag_service = get_rag_service() + chunks = rag_service.process_pdf(tmp_path) + + # Build index + rag_service.build_index(chunks) + + logger.info(f"Successfully indexed {len(chunks)} chunks from {file.filename}") + + return { + "message": f"Successfully uploaded and indexed PDF: {file.filename}", + "filename": file.filename, + "chunks": len(chunks), + "status": "success" + } + + finally: + # Clean up temporary file + if os.path.exists(tmp_path): + os.unlink(tmp_path) + + except Exception as e: + logger.error(f"Error uploading PDF: {str(e)}") + raise HTTPException( + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + detail=f"Error processing PDF: {str(e)}" + ) + + +@app.get("/rag/status") +def get_rag_status(): + """Get RAG index status""" + try: + rag_service = get_rag_service() + status_info = rag_service.get_status() + return status_info + except Exception as e: + logger.error(f"Error getting RAG status: {str(e)}") + raise HTTPException( + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + detail=f"Error getting status: {str(e)}" + ) + + +@app.delete("/rag/index") +def delete_rag_index(): + """Delete the RAG index""" + try: + rag_service = get_rag_service() + deleted = rag_service.delete_index() + return { + "message": "RAG index deleted successfully" if deleted else "No index to delete", + "status": "success" + } + except Exception as e: + logger.error(f"Error deleting RAG index: {str(e)}") + raise HTTPException( + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + detail=f"Error deleting index: {str(e)}" + ) + + +# Entry point for running with uvicorn +if __name__ == "__main__": + import uvicorn + uvicorn.run(app, host="0.0.0.0", port=5001) + diff --git a/sample_solutions/MultiAgentQnA/api/services/__init__.py b/sample_solutions/MultiAgentQnA/api/services/__init__.py new file mode 100644 index 00000000..9d574a1f --- /dev/null +++ b/sample_solutions/MultiAgentQnA/api/services/__init__.py @@ -0,0 +1,25 @@ +""" +Services module for Multi-Agent Q&A +""" + +from .api_client import get_api_client, APIClient +from .agents import ( + get_orchestration_agent, + get_code_agent, + get_rag_agent, + get_normal_agent, + update_agent_configs, + process_query +) + +__all__ = [ + "get_api_client", + "APIClient", + "get_orchestration_agent", + "get_code_agent", + "get_rag_agent", + "get_normal_agent", + "update_agent_configs", + "process_query" +] + diff --git a/sample_solutions/MultiAgentQnA/api/services/agents.py b/sample_solutions/MultiAgentQnA/api/services/agents.py new file mode 100644 index 00000000..f8e756c0 --- /dev/null +++ b/sample_solutions/MultiAgentQnA/api/services/agents.py @@ -0,0 +1,303 @@ +""" +Multi-Agent Q&A System +Simplified agent implementation without CrewAI dependency +""" + +import logging +from typing import Dict, Any, Optional +from datetime import datetime +from services.api_client import get_api_client +from services.rag_service import get_rag_service + +logger = logging.getLogger(__name__) + +# Activity logs for agent interactions +activity_logs = [] + + +def add_activity_log(message: str, log_type: str = "info"): + """Add an activity log entry""" + from datetime import datetime + activity_logs.append({ + "timestamp": datetime.now().isoformat(), + "type": log_type, + "message": message + }) + # Keep only last 500 logs + if len(activity_logs) > 500: + activity_logs.pop(0) + +# Default configurations +DEFAULT_ORCHESTRATION_CONFIG = { + "role": "Orchestration Coordinator", + "goal": "Analyze user queries and delegate them to the most appropriate specialized agent", + "backstory": "You are an expert coordinator who understands different types of questions. You excel at categorizing queries and routing them to the right specialist: code questions to developers, document questions to researchers, and general questions to assistants.", + "max_tokens": 500, + "temperature": 0.7 +} + +DEFAULT_CODE_CONFIG = { + "role": "Senior Software Developer", + "goal": "Answer coding questions with accurate, practical, and well-explained solutions", + "backstory": "You are an experienced software engineer with expertise in multiple programming languages. You provide clear, working code examples and best practices.", + "max_tokens": 500, + "temperature": 0.5 +} + +DEFAULT_RAG_CONFIG = { + "role": "Research Assistant", + "goal": "Retrieve information from documents and provide accurate answers", + "backstory": "You are a skilled researcher who excels at finding relevant information from knowledge bases and synthesizing comprehensive answers.", + "max_tokens": 800, + "temperature": 0.7 +} + +DEFAULT_NORMAL_CONFIG = { + "role": "Helpful Assistant", + "goal": "Provide clear, accurate, and helpful answers to general questions", + "backstory": "You are a knowledgeable assistant who loves helping people with their questions. You provide thoughtful and informative responses.", + "max_tokens": 500, + "temperature": 0.7 +} + + +def get_orchestration_agent(config: Optional[Dict[str, Any]] = None) -> Dict[str, Any]: + """Get orchestration agent configuration""" + return config if config else DEFAULT_ORCHESTRATION_CONFIG + + +def get_code_agent(config: Optional[Dict[str, Any]] = None) -> Dict[str, Any]: + """Get code agent configuration""" + return config if config else DEFAULT_CODE_CONFIG + + +def get_rag_agent(config: Optional[Dict[str, Any]] = None) -> Dict[str, Any]: + """Get RAG agent configuration""" + return config if config else DEFAULT_RAG_CONFIG + + +def get_normal_agent(config: Optional[Dict[str, Any]] = None) -> Dict[str, Any]: + """Get normal agent configuration""" + return config if config else DEFAULT_NORMAL_CONFIG + + +def determine_agent_type(query: str, verbose: bool = True) -> tuple[str, str]: + """ + Determine which agent should handle the query + + Args: + query: User query + verbose: Whether to log the decision + + Returns: + Tuple of (agent_type, reasoning) + """ + query_lower = query.lower() + + # Check for code-related keywords + code_keywords = ['code', 'programming', 'function', 'variable', 'debug', 'error', + 'python', 'javascript', 'java', 'c++', 'git', 'repo', 'repository', + 'algorithm', 'data structure', 'api', 'syntax', 'compile', 'test'] + if any(keyword in query_lower for keyword in code_keywords): + matched_keywords = [kw for kw in code_keywords if kw in query_lower] + reasoning = f"Code keywords detected: {', '.join(matched_keywords[:3])}" + if verbose: + logger.info(f"🔍 ORCHESTRATION: {reasoning} → Routing to Code Agent") + add_activity_log(f"🔍 {reasoning} → Routing to Code Agent", "info") + return 'code', reasoning + + # Check for document/retrieval-related keywords + rag_keywords = ['document', 'file', 'pdf', 'retrieve', 'search', 'find in', + 'according to', 'read', 'extract', 'index'] + if any(keyword in query_lower for keyword in rag_keywords): + matched_keywords = [kw for kw in rag_keywords if kw in query_lower] + reasoning = f"RAG keywords detected: {', '.join(matched_keywords[:3])}" + if verbose: + logger.info(f"🔍 ORCHESTRATION: {reasoning} → Routing to RAG Agent") + add_activity_log(f"🔍 {reasoning} → Routing to RAG Agent", "info") + return 'rag', reasoning + + # Default to normal agent + reasoning = "No specialized keywords found, using general agent" + if verbose: + logger.info(f"🔍 ORCHESTRATION: {reasoning} → Routing to General Agent") + add_activity_log(f"🔍 {reasoning} → Routing to General Agent", "info") + return 'normal', reasoning + + +def process_query(query: str, agent_config: Optional[Dict[str, Any]] = None, verbose: bool = True) -> tuple[str, str]: + """ + Process a query using the appropriate agent with full logging + + Args: + query: User query + agent_config: Optional agent configuration + verbose: Whether to log agent interactions + + Returns: + Tuple of (response, agent_name) + """ + # Step 1: Orchestration - Determine which agent to use + if verbose: + logger.info("=" * 80) + logger.info("🎯 ORCHESTRATION: Analyzing user query") + logger.info(f"📝 Query: {query}") + logger.info("=" * 80) + add_activity_log("🎯 ORCHESTRATION: Analyzing user query", "info") + add_activity_log(f"📝 Query: {query}", "info") + + agent_type, reasoning = determine_agent_type(query, verbose=verbose) + + try: + # Get agent configurations if provided + code_config = None + rag_config = None + normal_config = None + + if agent_config: + code_config = agent_config.get("code") + rag_config = agent_config.get("rag") + normal_config = agent_config.get("normal") + + # Get the appropriate agent config + if agent_type == 'code': + agent_config_data = get_code_agent(code_config) + agent_name = 'code_agent' + elif agent_type == 'rag': + agent_config_data = get_rag_agent(rag_config) + agent_name = 'rag_agent' + else: + agent_config_data = get_normal_agent(normal_config) + agent_name = 'normal_agent' + + # Step 2: Agent configuration + if verbose: + logger.info("") + logger.info(f"🤖 AGENT SELECTED: {agent_name}") + logger.info(f" Role: {agent_config_data.get('role', 'Assistant')}") + logger.info(f" Goal: {agent_config_data.get('goal', 'Help the user')}") + logger.info("") + add_activity_log(f"🤖 AGENT SELECTED: {agent_name}", "info") + add_activity_log(f" Role: {agent_config_data.get('role', 'Assistant')}", "info") + + # Build the prompt with agent context + role = agent_config_data.get("role", "Assistant") + goal = agent_config_data.get("goal", "Help the user") + backstory = agent_config_data.get("backstory", "You are a helpful assistant") + + # Step 3: Agent processing + if verbose: + logger.info("💭 AGENT THINKING: Processing query with agent-specific context...") + add_activity_log("💭 AGENT THINKING: Processing query with agent-specific context...", "info") + + api_client = get_api_client() + + # Handle RAG agent differently - search documents first + if agent_type == 'rag': + try: + rag_service = get_rag_service() + if verbose: + add_activity_log("🔍 RAG: Searching document index...", "info") + + # Search for relevant documents + results = rag_service.search(query, k=3) + + if results: + # Build context from retrieved documents + context_parts = [] + for i, result in enumerate(results, 1): + doc_text = result['document']['text'] + similarity = result['similarity'] + context_parts.append(f"Document {i} (similarity: {similarity:.2f}):\n{doc_text}") + + context = "\n\n".join(context_parts) + + if verbose: + add_activity_log(f"📄 RAG: Found {len(results)} relevant documents", "info") + logger.info(f"RAG retrieval: Found {len(results)} relevant documents") + + system_prompt = f"""You are a {role}. + +Your goal: {goal} + +{backstory} + +Use the following retrieved documents to answer the question. If the documents don't contain relevant information, say so. + +Retrieved Documents: +{context} + +Now answer the following question based on the documents above:""" + else: + if verbose: + add_activity_log("⚠️ RAG: No documents found in index", "warning") + + system_prompt = f"""You are a {role}. + +Your goal: {goal} + +{backstory} + +Note: No documents are currently indexed. You cannot answer questions about documents until documents are uploaded. + +Now answer the following question:""" + except Exception as e: + logger.error(f"Error in RAG retrieval: {str(e)}") + if verbose: + add_activity_log(f"❌ RAG Error: {str(e)}", "error") + + # Fall back to normal prompt + system_prompt = f"""You are a {role}. + +Your goal: {goal} + +{backstory} + +Now answer the following question:""" + else: + # For non-RAG agents, use standard prompt + system_prompt = f"""You are a {role}. + +Your goal: {goal} + +{backstory} + +Now answer the following question:""" + + messages = [ + {"role": "system", "content": system_prompt}, + {"role": "user", "content": query} + ] + + response = api_client.chat_complete( + messages=messages, + max_tokens=agent_config_data.get("max_tokens", 500), + temperature=agent_config_data.get("temperature", 0.7) + ) + + if verbose: + logger.info(f"✅ AGENT RESPONSE: Generated {len(str(response))} characters") + logger.info("=" * 80) + logger.info("") + add_activity_log(f"✅ AGENT RESPONSE: Generated {len(str(response))} characters", "success") + + return str(response), agent_name + + except Exception as e: + error_msg = f"❌ ERROR: {str(e)}" + logger.error(error_msg, exc_info=True) + add_activity_log(error_msg, "error") + raise + + +def update_agent_configs(configs: Dict[str, Any]) -> None: + """ + Update all agent configurations (stored as defaults for future queries) + + Args: + configs: Dictionary containing agent configurations + """ + # In this simplified version, configs are used at query time + # This function exists for API compatibility + logger.info("Agent configurations updated") + diff --git a/sample_solutions/MultiAgentQnA/api/services/api_client.py b/sample_solutions/MultiAgentQnA/api/services/api_client.py new file mode 100644 index 00000000..833afdaf --- /dev/null +++ b/sample_solutions/MultiAgentQnA/api/services/api_client.py @@ -0,0 +1,185 @@ +""" +API Client for authentication and API calls +Similar to rag-chatbot implementation +""" + +import logging +import requests +import httpx +from typing import Optional +import config + +logger = logging.getLogger(__name__) + + +class APIClient: + """ + Client for handling API calls with token-based authentication + """ + + def __init__(self): + self.base_url = config.INFERENCE_API_ENDPOINT + self.token = config.INFERENCE_API_TOKEN + self.http_client = httpx.Client(verify=False) + logger.info(f"✓ API Client initialized with endpoint: {self.base_url}") + + def get_embedding_client(self): + """ + Get OpenAI-style client for embeddings + Uses bge-base-en-v1.5 model + """ + from openai import OpenAI + + return OpenAI( + api_key=self.token, + base_url=f"{self.base_url}/v1", + http_client=self.http_client + ) + + def get_inference_client(self): + """ + Get OpenAI-style client for inference/completions + Uses Llama-3.1-8B-Instruct model + """ + from openai import OpenAI + + return OpenAI( + api_key=self.token, + base_url=f"{self.base_url}/v1", + http_client=self.http_client + ) + + def embed_text(self, text: str) -> list: + """ + Get embedding for text + Uses the bge-base-en-v1.5 embedding model + + Args: + text: Text to embed + + Returns: + List of embedding values + """ + try: + client = self.get_embedding_client() + # Call the embeddings endpoint + response = client.embeddings.create( + model=config.EMBEDDING_MODEL_NAME, + input=text + ) + return response.data[0].embedding + except Exception as e: + logger.error(f"Error generating embedding: {str(e)}") + raise + + def embed_texts(self, texts: list) -> list: + """ + Get embeddings for multiple texts + Batches requests to avoid exceeding API limits (max batch size: 32) + + Args: + texts: List of texts to embed + + Returns: + List of embedding vectors + """ + try: + BATCH_SIZE = 32 # Maximum allowed batch size + all_embeddings = [] + client = self.get_embedding_client() + + # Process in batches of 32 + for i in range(0, len(texts), BATCH_SIZE): + batch = texts[i:i + BATCH_SIZE] + logger.info(f"Processing embedding batch {i//BATCH_SIZE + 1}/{(len(texts) + BATCH_SIZE - 1)//BATCH_SIZE} ({len(batch)} texts)") + + response = client.embeddings.create( + model=config.EMBEDDING_MODEL_NAME, + input=batch + ) + batch_embeddings = [data.embedding for data in response.data] + all_embeddings.extend(batch_embeddings) + + return all_embeddings + except Exception as e: + logger.error(f"Error generating embeddings: {str(e)}") + raise + + def chat_complete(self, messages: list, max_tokens: int = 500, temperature: float = 0.7) -> str: + """ + Get chat completion from the inference model + + Args: + messages: List of message dicts with 'role' and 'content' + max_tokens: Maximum tokens to generate + temperature: Temperature for generation + + Returns: + Generated text + """ + try: + client = self.get_inference_client() + # Convert messages to a prompt for the completions endpoint + # (since Llama models use completions, not chat.completions) + prompt = "" + for msg in messages: + role = msg.get('role', 'user') + content = msg.get('content', '') + if role == 'system': + prompt += f"System: {content}\n\n" + elif role == 'user': + prompt += f"User: {content}\n\n" + elif role == 'assistant': + prompt += f"Assistant: {content}\n\n" + prompt += "Assistant:" + + logger.info(f"Calling inference with prompt length: {len(prompt)}") + + response = client.completions.create( + model=config.INFERENCE_MODEL_NAME, + prompt=prompt, + max_tokens=max_tokens, + temperature=temperature + ) + + # Handle response structure + if hasattr(response, 'choices') and len(response.choices) > 0: + choice = response.choices[0] + if hasattr(choice, 'text'): + return choice.text + elif hasattr(choice, 'message') and hasattr(choice.message, 'content'): + return choice.message.content + else: + logger.error(f"Unexpected response structure: {type(choice)}, {choice}") + return str(choice) + else: + logger.error(f"Unexpected response: {type(response)}, {response}") + return "" + except Exception as e: + logger.error(f"Error generating chat completion: {str(e)}", exc_info=True) + raise + + def __del__(self): + """ + Cleanup: close httpx client + """ + if self.http_client: + self.http_client.close() + + +# Global API client instance +_api_client: Optional[APIClient] = None + + +def get_api_client() -> APIClient: + """ + Get or create the global API client instance + + Returns: + APIClient instance + """ + global _api_client + if _api_client is None: + _api_client = APIClient() + return _api_client + diff --git a/sample_solutions/MultiAgentQnA/api/services/rag_service.py b/sample_solutions/MultiAgentQnA/api/services/rag_service.py new file mode 100644 index 00000000..874b7d14 --- /dev/null +++ b/sample_solutions/MultiAgentQnA/api/services/rag_service.py @@ -0,0 +1,293 @@ +""" +RAG Service for PDF processing and vector store management +Handles PDF parsing, text chunking, and FAISS vector operations +""" + +import os +import logging +import shutil +from typing import List, Optional, Dict, Any +import numpy as np +import faiss +from pypdf import PdfReader +import config +from services.api_client import get_api_client + +logger = logging.getLogger(__name__) + +# Constants +VECTOR_STORE_DIR = "./rag_index" +CHUNK_SIZE = 1000 # Characters per chunk +CHUNK_OVERLAP = 200 # Overlap between chunks + + +class RAGService: + """ + Service for RAG operations: PDF processing, embedding, and retrieval + """ + + def __init__(self): + self.api_client = get_api_client() + self.vector_store_path = VECTOR_STORE_DIR + self.index: Optional[faiss.Index] = None + self.documents: List[Dict[str, Any]] = [] + self._ensure_directory() + + def _ensure_directory(self): + """Ensure the vector store directory exists""" + os.makedirs(self.vector_store_path, exist_ok=True) + + def process_pdf(self, pdf_path: str) -> List[Dict[str, Any]]: + """ + Process a PDF file and extract text chunks + + Args: + pdf_path: Path to the PDF file + + Returns: + List of document chunks with metadata + """ + try: + logger.info(f"Processing PDF: {pdf_path}") + reader = PdfReader(pdf_path) + + # Extract text from all pages + full_text = "" + for i, page in enumerate(reader.pages): + page_text = page.extract_text() + if page_text: + full_text += f"\n--- Page {i+1} ---\n{page_text}\n" + + if not full_text.strip(): + raise ValueError("No text extracted from PDF") + + # Chunk the text + chunks = self._chunk_text(full_text, metadata={"source": pdf_path}) + + logger.info(f"Extracted {len(chunks)} chunks from PDF") + return chunks + + except Exception as e: + logger.error(f"Error processing PDF: {str(e)}") + raise + + def _chunk_text(self, text: str, metadata: Dict[str, Any]) -> List[Dict[str, Any]]: + """ + Split text into overlapping chunks + + Args: + text: Text to chunk + metadata: Metadata to attach to chunks + + Returns: + List of chunk dictionaries + """ + chunks = [] + + # Split by paragraphs first + paragraphs = text.split('\n\n') + current_chunk = "" + current_size = 0 + + for para in paragraphs: + para_size = len(para) + + # If adding this paragraph would exceed chunk size, save current chunk + if current_size + para_size > CHUNK_SIZE and current_chunk: + chunks.append({ + "text": current_chunk, + "metadata": {**metadata, "chunk_index": len(chunks)} + }) + + # Start new chunk with overlap + overlap_text = current_chunk[-CHUNK_OVERLAP:] if len(current_chunk) > CHUNK_OVERLAP else current_chunk + current_chunk = overlap_text + " " + para + current_size = len(current_chunk) + else: + current_chunk += "\n\n" + para if current_chunk else para + current_size = len(current_chunk) + + # Add the last chunk + if current_chunk: + chunks.append({ + "text": current_chunk, + "metadata": {**metadata, "chunk_index": len(chunks)} + }) + + return chunks + + def build_index(self, chunks: List[Dict[str, Any]]) -> None: + """ + Create embeddings and build FAISS index + + Args: + chunks: List of document chunks + """ + try: + logger.info(f"Building FAISS index with {len(chunks)} chunks") + + # Extract texts + texts = [chunk["text"] for chunk in chunks] + + # Get embeddings from API + embeddings = self.api_client.embed_texts(texts) + + # Convert to numpy array + embedding_dim = len(embeddings[0]) + embeddings_array = np.array(embeddings, dtype=np.float32) + + # Create FAISS index (using L2 distance) + self.index = faiss.IndexFlatL2(embedding_dim) + self.index.add(embeddings_array) + + # Store documents + self.documents = chunks + + # Save to disk + self._save_index() + + logger.info(f"Index built successfully with {self.index.ntotal} vectors") + + except Exception as e: + logger.error(f"Error building index: {str(e)}") + raise + + def _save_index(self): + """Save FAISS index and documents to disk""" + try: + # Save FAISS index + faiss.write_index(self.index, os.path.join(self.vector_store_path, "index.faiss")) + + # Save documents as a simple format (JSON would be better but keeping it simple) + import pickle + with open(os.path.join(self.vector_store_path, "documents.pkl"), "wb") as f: + pickle.dump(self.documents, f) + + logger.info(f"Index saved to {self.vector_store_path}") + + except Exception as e: + logger.error(f"Error saving index: {str(e)}") + raise + + def load_index(self) -> bool: + """ + Load FAISS index from disk + + Returns: + True if loaded successfully, False otherwise + """ + try: + faiss_path = os.path.join(self.vector_store_path, "index.faiss") + docs_path = os.path.join(self.vector_store_path, "documents.pkl") + + if not os.path.exists(faiss_path) or not os.path.exists(docs_path): + logger.warning("No existing index found") + return False + + # Load FAISS index + self.index = faiss.read_index(faiss_path) + + # Load documents + import pickle + with open(docs_path, "rb") as f: + self.documents = pickle.load(f) + + logger.info(f"Loaded index with {self.index.ntotal} vectors") + return True + + except Exception as e: + logger.error(f"Error loading index: {str(e)}") + return False + + def search(self, query: str, k: int = 3) -> List[Dict[str, Any]]: + """ + Search for similar documents + + Args: + query: Search query + k: Number of results to return + + Returns: + List of matching documents with similarity scores + """ + try: + if not self.index or self.index.ntotal == 0: + logger.warning("No index loaded or index is empty") + return [] + + # Get query embedding + query_embedding = self.api_client.embed_text(query) + query_vector = np.array([query_embedding], dtype=np.float32) + + # Search + distances, indices = self.index.search(query_vector, k) + + # Retrieve documents + results = [] + for i, idx in enumerate(indices[0]): + if idx < len(self.documents): + results.append({ + "document": self.documents[idx], + "score": float(distances[0][i]), + "similarity": 1.0 / (1.0 + float(distances[0][i])) # Convert distance to similarity + }) + + return results + + except Exception as e: + logger.error(f"Error searching: {str(e)}") + raise + + def delete_index(self) -> bool: + """ + Delete the vector store + + Returns: + True if deleted successfully + """ + try: + if os.path.exists(self.vector_store_path): + shutil.rmtree(self.vector_store_path) + logger.info("Vector store deleted") + self.index = None + self.documents = [] + return True + return False + + except Exception as e: + logger.error(f"Error deleting vector store: {str(e)}") + raise + + def get_status(self) -> Dict[str, Any]: + """ + Get the status of the vector store + + Returns: + Dictionary with status information + """ + return { + "index_exists": self.index is not None, + "num_documents": self.index.ntotal if self.index else 0, + "num_vectors": self.index.ntotal if self.index else 0, + "path": self.vector_store_path + } + + +# Global RAG service instance +_rag_service: Optional[RAGService] = None + + +def get_rag_service() -> RAGService: + """ + Get or create the global RAG service instance + + Returns: + RAGService instance + """ + global _rag_service + if _rag_service is None: + _rag_service = RAGService() + # Try to load existing index + _rag_service.load_index() + return _rag_service + diff --git a/sample_solutions/MultiAgentQnA/docker-compose.yml b/sample_solutions/MultiAgentQnA/docker-compose.yml new file mode 100644 index 00000000..7a6d0455 --- /dev/null +++ b/sample_solutions/MultiAgentQnA/docker-compose.yml @@ -0,0 +1,40 @@ +services: + # Backend API (Python) + backend: + build: + context: ./api + dockerfile: Dockerfile + container_name: multiagent-qna-backend + ports: + - "5001:5001" + env_file: + - ./api/.env + volumes: + - ./api:/app + networks: + - app_network + extra_hosts: + - "${LOCAL_URL_ENDPOINT}:host-gateway" + restart: unless-stopped + + # Frontend UI (React) + frontend: + build: + context: ./ui + dockerfile: Dockerfile + container_name: multiagent-qna-frontend + ports: + - "3000:3000" + depends_on: + - backend + networks: + - app_network + restart: unless-stopped + +################################## +# 🔗 Shared Network +################################## +networks: + app_network: + driver: bridge + diff --git a/sample_solutions/MultiAgentQnA/images/ui.png b/sample_solutions/MultiAgentQnA/images/ui.png new file mode 100644 index 0000000000000000000000000000000000000000..fa9a77802ad9b8b7dbfb51c34551d2e36e25e4e3 GIT binary patch literal 254805 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 z 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 literal 0 HcmV?d00001 diff --git a/sample_solutions/MultiAgentQnA/ui/Dockerfile b/sample_solutions/MultiAgentQnA/ui/Dockerfile new file mode 100644 index 00000000..4a92b940 --- /dev/null +++ b/sample_solutions/MultiAgentQnA/ui/Dockerfile @@ -0,0 +1,20 @@ +FROM node:18 + +# Set the working directory +WORKDIR /app + +# Copy package.json +COPY package.json ./ + +# Install dependencies (this will create package-lock.json if missing) +RUN npm install + +# Copy the rest of the application files +COPY . . + +# Expose the port the app runs on +EXPOSE 3000 + +# Command to run the application +CMD ["npm", "run", "dev"] + diff --git a/sample_solutions/MultiAgentQnA/ui/index.html b/sample_solutions/MultiAgentQnA/ui/index.html new file mode 100644 index 00000000..7f3995c6 --- /dev/null +++ b/sample_solutions/MultiAgentQnA/ui/index.html @@ -0,0 +1,14 @@ + + + + + + + Multi-Agent Q&A + + +

+ + + + diff --git a/sample_solutions/MultiAgentQnA/ui/package.json b/sample_solutions/MultiAgentQnA/ui/package.json new file mode 100644 index 00000000..d4caceaf --- /dev/null +++ b/sample_solutions/MultiAgentQnA/ui/package.json @@ -0,0 +1,32 @@ +{ + "name": "multiagent-qna-ui", + "version": "1.0.0", + "private": true, + "type": "module", + "scripts": { + "dev": "vite", + "build": "vite build", + "preview": "vite preview", + "lint": "eslint . --ext js,jsx --report-unused-disable-directives --max-warnings 0" + }, + "dependencies": { + "react": "^18.2.0", + "react-dom": "^18.2.0", + "axios": "^1.6.0", + "lucide-react": "^0.294.0" + }, + "devDependencies": { + "@types/react": "^18.2.43", + "@types/react-dom": "^18.2.17", + "@vitejs/plugin-react": "^4.2.1", + "autoprefixer": "^10.4.16", + "eslint": "^8.55.0", + "eslint-plugin-react": "^7.33.2", + "eslint-plugin-react-hooks": "^4.6.0", + "eslint-plugin-react-refresh": "^0.4.5", + "postcss": "^8.4.32", + "tailwindcss": "^3.3.6", + "vite": "^5.0.8" + } +} + diff --git a/sample_solutions/MultiAgentQnA/ui/postcss.config.js b/sample_solutions/MultiAgentQnA/ui/postcss.config.js new file mode 100644 index 00000000..b4a6220e --- /dev/null +++ b/sample_solutions/MultiAgentQnA/ui/postcss.config.js @@ -0,0 +1,7 @@ +export default { + plugins: { + tailwindcss: {}, + autoprefixer: {}, + }, +} + diff --git a/sample_solutions/MultiAgentQnA/ui/src/App.jsx b/sample_solutions/MultiAgentQnA/ui/src/App.jsx new file mode 100644 index 00000000..36984f97 --- /dev/null +++ b/sample_solutions/MultiAgentQnA/ui/src/App.jsx @@ -0,0 +1,30 @@ +import { useState } from 'react' +import Header from './components/Header' +import ChatInterface from './components/ChatInterface' +import SettingsPage from './components/SettingsPage' +import LogsPanel from './components/LogsPanel' + +function App() { + const [currentPage, setCurrentPage] = useState('chat') + const [logsOpen, setLogsOpen] = useState(false) + + return ( +
+
setLogsOpen(!logsOpen)} + /> + +
+ {currentPage === 'chat' && } + {currentPage === 'settings' && } +
+ + setLogsOpen(false)} /> +
+ ) +} + +export default App + diff --git a/sample_solutions/MultiAgentQnA/ui/src/components/ChatInterface.jsx b/sample_solutions/MultiAgentQnA/ui/src/components/ChatInterface.jsx new file mode 100644 index 00000000..51ff0701 --- /dev/null +++ b/sample_solutions/MultiAgentQnA/ui/src/components/ChatInterface.jsx @@ -0,0 +1,320 @@ +import { useState, useRef, useEffect } from 'react' +import { Send, Bot, User, AlertCircle, Code, FileText, MessageCircle, Upload, Check, X } from 'lucide-react' +import { sendChatMessage, uploadPDF, getRAGStatus } from '../services/api' + +export default function ChatInterface() { + const [messages, setMessages] = useState([]) + const [input, setInput] = useState('') + const [isLoading, setIsLoading] = useState(false) + const [uploading, setUploading] = useState(false) + const [uploadStatus, setUploadStatus] = useState(null) + const [ragStatus, setRagStatus] = useState(null) + const messagesEndRef = useRef(null) + const fileInputRef = useRef(null) + + const scrollToBottom = () => { + messagesEndRef.current?.scrollIntoView({ behavior: "smooth" }) + } + + useEffect(() => { + scrollToBottom() + }, [messages]) + + useEffect(() => { + loadRAGStatus() + }, []) + + const loadRAGStatus = async () => { + try { + const status = await getRAGStatus() + setRagStatus(status) + } catch (error) { + console.error('Error loading RAG status:', error) + } + } + + const handleFileUpload = async (e) => { + const file = e.target.files[0] + console.log('File selected:', file) + + if (!file) { + console.log('No file selected') + return + } + + if (!file.type.includes('pdf')) { + alert('Only PDF files are supported') + return + } + + console.log('Starting upload for:', file.name) + setUploading(true) + setUploadStatus(null) + + try { + const result = await uploadPDF(file) + console.log('Upload successful:', result) + setUploadStatus({ success: true, message: result.message, chunks: result.chunks }) + await loadRAGStatus() + + // Show success message in chat + const successMsg = { + type: 'assistant', + content: `✅ PDF uploaded successfully! Indexed ${result.chunks} chunks. You can now ask questions about this document.`, + timestamp: new Date() + } + setMessages(prev => [...prev, successMsg]) + } catch (error) { + console.error('Upload error:', error) + setUploadStatus({ success: false, message: error.message }) + const errorMsg = { + type: 'error', + content: `Failed to upload PDF: ${error.message}`, + timestamp: new Date() + } + setMessages(prev => [...prev, errorMsg]) + } finally { + setUploading(false) + // Clear file input + if (fileInputRef.current) { + fileInputRef.current.value = '' + } + } + } + + const handleSubmit = async (e) => { + e.preventDefault() + + if (!input.trim()) return + + const userMessage = { + type: 'user', + content: input, + timestamp: new Date() + } + + setMessages(prev => [...prev, userMessage]) + setInput('') + setIsLoading(true) + + try { + const response = await sendChatMessage(input) + + const botMessage = { + type: 'assistant', + content: response.response, + agent: response.agent, + timestamp: new Date() + } + + setMessages(prev => [...prev, botMessage]) + } catch (error) { + const errorMessage = { + type: 'error', + content: error.message || 'Failed to get response. Please try again.', + timestamp: new Date() + } + setMessages(prev => [...prev, errorMessage]) + } finally { + setIsLoading(false) + } + } + + const getAgentIcon = (agent) => { + switch (agent) { + case 'code_agent': + return + case 'rag_agent': + return + case 'normal_agent': + return + default: + return + } + } + + const getAgentBadge = (agent) => { + switch (agent) { + case 'code_agent': + return + Code Agent + + case 'rag_agent': + return + RAG Agent + + case 'normal_agent': + return + General Agent + + default: + return null + } + } + + return ( +
+ {/* Chat Header */} +
+
+

+ + Multi-Agent Chat +

+ {ragStatus && ragStatus.index_exists && ( + + 📄 {ragStatus.num_documents} docs indexed + + )} +
+

+ Ask anything - code questions, document queries, or general questions +

+
+ + {/* Messages Container */} +
+ {messages.length === 0 && ( +
+
+ +
+

Get Started

+

Our intelligent multi-agent system will route your question to the best specialist:

+
+
+ + Code Agent - Programming, algorithms, debugging +
+
+ + RAG Agent - Document retrieval and research +
+
+ + General Agent - Everything else +
+
+
+
+
+ )} + + {messages.map((message, index) => ( +
+
+ {message.type === 'user' ? ( + + ) : message.type === 'error' ? ( + + ) : ( + getAgentIcon(message.agent) + )} +
+ +
+ {message.agent && message.type !== 'error' && ( +
+ {getAgentBadge(message.agent)} +
+ )} +
+

{message.content}

+
+

+ {message.timestamp.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' })} +

+
+
+ ))} + + {isLoading && ( +
+
+ +
+
+
+
+
+
+
+
+
+ )} + +
+
+ + {/* Input Form */} +
+
+ setInput(e.target.value)} + placeholder="Ask a question..." + disabled={isLoading || uploading} + className="flex-1 px-4 py-2 border border-gray-300 rounded-lg focus:outline-none focus:ring-2 focus:ring-purple-500 disabled:bg-gray-100 disabled:cursor-not-allowed" + /> + + + +
+

+ Press Enter to send • Upload PDFs for document questions • The AI will route your question to the best specialist +

+
+
+ ) +} + diff --git a/sample_solutions/MultiAgentQnA/ui/src/components/Header.jsx b/sample_solutions/MultiAgentQnA/ui/src/components/Header.jsx new file mode 100644 index 00000000..c2db2982 --- /dev/null +++ b/sample_solutions/MultiAgentQnA/ui/src/components/Header.jsx @@ -0,0 +1,53 @@ +import { Bot, Terminal } from 'lucide-react' + +export default function Header({ currentPage, onPageChange, onLogsToggle }) { + return ( +
+
+
+
+
+ +
+
+

Multi-Agent Q&A

+

Intelligent question answering with specialized agents

+
+
+ + +
+
+
+ ) +} + diff --git a/sample_solutions/MultiAgentQnA/ui/src/components/LogsPanel.jsx b/sample_solutions/MultiAgentQnA/ui/src/components/LogsPanel.jsx new file mode 100644 index 00000000..281a66fd --- /dev/null +++ b/sample_solutions/MultiAgentQnA/ui/src/components/LogsPanel.jsx @@ -0,0 +1,134 @@ +import { useState, useEffect } from 'react' +import { Terminal, Copy, Check, X, RefreshCw } from 'lucide-react' +import { getLogs } from '../services/api' + +export default function LogsPanel({ isOpen, onClose }) { + const [logs, setLogs] = useState([]) + const [copied, setCopied] = useState(false) + const [autoRefresh, setAutoRefresh] = useState(true) + + const fetchLogs = async () => { + try { + const response = await getLogs() + if (response && response.logs) { + setLogs(response.logs.reverse()) // Show newest first + } + } catch (error) { + console.error('Error fetching logs:', error) + } + } + + useEffect(() => { + if (isOpen) { + fetchLogs() + } + }, [isOpen]) + + useEffect(() => { + if (isOpen && autoRefresh) { + const interval = setInterval(fetchLogs, 2000) // Refresh every 2 seconds + return () => clearInterval(interval) + } + }, [isOpen, autoRefresh]) + + const copyLogs = () => { + const logsText = logs.map(log => { + const timestamp = new Date(log.timestamp).toLocaleTimeString() + return `[${timestamp}] ${log.type.toUpperCase()}: ${log.message}` + }).join('\n') + navigator.clipboard.writeText(logsText) + setCopied(true) + setTimeout(() => setCopied(false), 2000) + } + + const clearLogs = () => { + setLogs([]) + fetchLogs() + } + + if (!isOpen) return null + + return ( +
+
+ {/* Header */} +
+
+ +

Agent Activity Logs

+
+
+ + + +
+
+ + {/* Logs Content */} +
+ {logs.length === 0 ? ( +
+ No logs available yet +
+ ) : ( +
+ {logs.map((log, index) => ( +
+ + {new Date(log.timestamp).toLocaleTimeString()} + + + [{log.type.toUpperCase()}] + + {log.message} +
+ ))} +
+ )} +
+ + {/* Footer */} +
+ 💡 These logs show agent routing decisions and activity in real-time +
+
+
+ ) +} + diff --git a/sample_solutions/MultiAgentQnA/ui/src/components/SettingsPage.jsx b/sample_solutions/MultiAgentQnA/ui/src/components/SettingsPage.jsx new file mode 100644 index 00000000..9893a5fd --- /dev/null +++ b/sample_solutions/MultiAgentQnA/ui/src/components/SettingsPage.jsx @@ -0,0 +1,245 @@ +import { useState, useEffect } from 'react' +import { Save, Code, FileText, MessageCircle, Settings as SettingsIcon } from 'lucide-react' +import { getAgentConfig, updateAgentConfig } from '../services/api' + +export default function SettingsPage() { + const [config, setConfig] = useState({ + orchestration: { + role: '', + goal: '', + backstory: '', + max_iter: 15, + verbose: true + }, + code: { + role: '', + goal: '', + backstory: '', + max_iter: 15, + verbose: true + }, + rag: { + role: '', + goal: '', + backstory: '', + max_iter: 15, + verbose: true + }, + normal: { + role: '', + goal: '', + backstory: '', + max_iter: 15, + verbose: true + } + }) + + const [isLoading, setIsLoading] = useState(false) + const [isSaving, setIsSaving] = useState(false) + const [message, setMessage] = useState('') + + useEffect(() => { + loadConfig() + }, []) + + const loadConfig = async () => { + setIsLoading(true) + try { + const response = await getAgentConfig() + setConfig(response.config) + } catch (error) { + setMessage('Failed to load configuration. Using defaults.') + } finally { + setIsLoading(false) + } + } + + const handleSave = async () => { + setIsSaving(true) + setMessage('') + + try { + await updateAgentConfig(config) + setMessage('Configuration saved successfully!') + } catch (error) { + setMessage('Failed to save configuration.') + } finally { + setIsSaving(false) + setTimeout(() => setMessage(''), 3000) + } + } + + const handleAgentConfigChange = (agentType, field, value) => { + setConfig(prev => ({ + ...prev, + [agentType]: { + ...prev[agentType], + [field]: value + } + })) + } + + const AgentConfigCard = ({ agentType, agentName, icon: Icon, color }) => { + const colorClasses = { + purple: { bg: 'bg-purple-100', text: 'text-purple-600' }, + blue: { bg: 'bg-blue-100', text: 'text-blue-600' }, + green: { bg: 'bg-green-100', text: 'text-green-600' } + } + const classes = colorClasses[color] || colorClasses.purple + + return ( +
+
+
+ +
+

{agentName}

+
+ +
+
+ + handleAgentConfigChange(agentType, 'role', e.target.value)} + className="w-full px-3 py-2 border border-gray-300 rounded-lg focus:outline-none focus:ring-2 focus:ring-purple-500" + placeholder="e.g., Senior Software Developer" + /> +
+ +
+ +