Uploaded from local

.dockerignore

@@ -0,0 +1,66 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+venv/
+env/
+ENV/
+*.egg-info/
+.pytest_cache/
+.coverage
+htmlcov/
+
+# Environment and secrets
+.env
+.env.*
+*.pem
+*.key
+credentials.json
+secrets.toml
+
+# Git
+.git/
+.gitignore
+.github/
+
+# IDEs
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Documentation
+README.md
+*.md
+docs/
+
+# Docker
+Dockerfile*
+docker-compose*.yml
+.dockerignore
+
+# Jupyter
+*.ipynb
+.ipynb_checkpoints/
+
+# Old files
+OLD/
+
+# Logs
+*.log
+
+# Database
+*.db
+*.sqlite
+*.sqlite3
+
+# Temporary files
+tmp/
+temp/
+*.tmp

.env.example

@@ -0,0 +1,74 @@
+# =============================================================================
+# HUGGING FACE SPACES - ENVIRONMENT VARIABLES TEMPLATE
+# =============================================================================
+# Copy these variables to your Hugging Face Space Settings > Variables and Secrets
+# DO NOT commit actual API keys to version control
+# =============================================================================
+
+# =============================================================================
+# REQUIRED: Core API Keys (Must be configured)
+# =============================================================================
+
+# Google Gemini API Key
+# Get from: https://makersuite.google.com/app/apikey
+GOOGLE_API_KEY=your_google_gemini_api_key_here
+
+# ChromaDB Cloud API Key (for RAG document storage)
+# Get from: https://www.trychroma.com/
+CHROMA_API_KEY=your_chroma_api_key_here
+CHROMA_TENANT=your_tenant_id
+CHROMA_DATABASE=your_database_name
+
+# Alpha Vantage API Key (for stock market data)
+# Get from: https://www.alphavantage.co/support/#api-key
+ALPHA_VANTAGE_API_KEY=your_alpha_vantage_api_key_here
+
+# =============================================================================
+# OPTIONAL: Enhanced Features
+# =============================================================================
+
+# CoinGecko Pro API Key (for enhanced crypto data)
+# Get from: https://www.coingecko.com/en/api/pricing
+# Note: Free tier available without API key (rate limited)
+COINGECKO_API_KEY=your_coingecko_api_key_here
+
+# =============================================================================
+# OPTIONAL: Google Cloud SQL (for Portfolio Tracking)
+# =============================================================================
+# Only needed if you want persistent portfolio tracking with Cloud SQL
+# Otherwise, portfolio data is ephemeral within the session
+
+# Google Cloud Project Configuration
+GCP_PROJECT_ID=your_gcp_project_id
+CLOUD_SQL_REGION=us-central1
+CLOUD_SQL_INSTANCE=your_instance_name
+
+# Cloud SQL Database Credentials
+CLOUD_SQL_INSTANCE_CONNECTION_NAME=project:region:instance
+CLOUD_SQL_DB_NAME=finance_tracker
+CLOUD_SQL_DB_USER=your_db_user
+CLOUD_SQL_DB_PASS=your_db_password
+
+# MCP Toolbox Server URL (for Cloud SQL access)
+# If running MCP Toolbox as separate service/container
+MCP_TOOLBOX_SERVER_URL=http://localhost:5000
+
+# =============================================================================
+# OPTIONAL: ChromaDB Configuration
+# =============================================================================
+
+# ChromaDB Cloud Host
+CHROMA_CLOUD_HOST=api.trychroma.com
+
+# ChromaDB Collection Name
+DOCUMENTS_COLLECTION=mcp-test
+
+# Embedding Function (default, openai, cohere, jina, voyageai)
+CHROMA_EMBEDDING_FUNCTION=default
+
+# =============================================================================
+# OPTIONAL: UI Configuration
+# =============================================================================
+
+# Maximum file upload size (in MB)
+MAX_FILE_SIZE_MB=50

.github/workflows/aws.yaml

@@ -0,0 +1,128 @@
+name: CI/CD to ECS Fargate
+on:
+  workflow_run:
+    workflows: ["Run Unit Tests"]
+    types:
+      - completed
+env:
+  AWS_REGION: eu-west-3
+  ECR_REPOSITORY: multi-agent-app
+  ECR_REPOSITORY_TOOLBOX: mcp-toolbox
+  ECS_SERVICE: multi-agent-service
+  ECS_CLUSTER: multi-agent-cluster
+  ECS_TASK_DEFINITION: .github/workflows/task_definition.json
+  CONTAINER_NAME: multi-agent-app
+
+permissions:
+  id-token: write
+  contents: read
+
+jobs:
+  check-status:
+    runs-on: ubuntu-latest
+    if: ${{github.event.workflow_run.conclusion == 'success' && github.event.workflow_run.head_branch == 'main'}}
+    steps:
+      - name: CI passed on main branch
+        run: echo "CI passed on main branch, proceeding to build and deploy."
+
+  # -------------------------------
+  # 1. Build & Push Docker Images
+  # -------------------------------
+  build-and-push:
+    name: Build & Push Docker Images
+    needs: [check-status]
+    runs-on: ubuntu-latest
+    outputs:
+      image: ${{ steps.build-image.outputs.image }}
+      toolbox-image: ${{ steps.build-toolbox.outputs.image }}
+    steps:
+      - name: Checkout Repo
+        uses: actions/checkout@v4
+
+      - name: Configure AWS Credentials
+        uses: aws-actions/configure-aws-credentials@v4
+        with:
+          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
+          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+          aws-region: ${{ env.AWS_REGION }}
+
+      - name: Login to Amazon ECR
+        id: login-ecr
+        uses: aws-actions/amazon-ecr-login@v2
+
+      - name: Build and Push Main App Image
+        id: build-image
+        env:
+          ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }}
+          IMAGE_TAG: ${{ github.sha }}
+        run: |
+          IMAGE_URI=$ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG
+          echo "IMAGE_URI=$IMAGE_URI" >> $GITHUB_ENV
+          docker build -f docker/Dockerfile -t $IMAGE_URI .
+          docker push $IMAGE_URI
+          echo "image=$IMAGE_URI" >> $GITHUB_OUTPUT
+
+      - name: Build and Push MCP Toolbox Image
+        id: build-toolbox
+        env:
+          ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }}
+          IMAGE_TAG: ${{ github.sha }}
+        run: |
+          TOOLBOX_IMAGE_URI=$ECR_REGISTRY/$ECR_REPOSITORY_TOOLBOX:$IMAGE_TAG
+          docker build -f docker/Dockerfile.toolbox -t $TOOLBOX_IMAGE_URI .
+          docker push $TOOLBOX_IMAGE_URI
+
+          # Also tag and push as 'latest'
+          TOOLBOX_LATEST=$ECR_REGISTRY/$ECR_REPOSITORY_TOOLBOX:latest
+          docker tag $TOOLBOX_IMAGE_URI $TOOLBOX_LATEST
+          docker push $TOOLBOX_LATEST
+
+          echo "image=$TOOLBOX_IMAGE_URI" >> $GITHUB_OUTPUT
+
+  # -------------------------------
+  # 2. Deploy to ECS
+  # -------------------------------
+  deploy:
+    name: Deploy to ECS Fargate
+    needs: build-and-push
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Repo
+        uses: actions/checkout@v4
+
+      - name: Configure AWS Credentials
+        uses: aws-actions/configure-aws-credentials@v1
+        with:
+          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
+          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+          aws-region: ${{ env.AWS_REGION }}
+
+      - name: Render Main App Container in Task Definition
+        id: render-app
+        uses: aws-actions/amazon-ecs-render-task-definition@v1
+        with:
+          task-definition: ${{ env.ECS_TASK_DEFINITION }}
+          container-name: ${{ env.CONTAINER_NAME }}
+          image: ${{ needs.build-and-push.outputs.image }}
+
+      - name: Render MCP Toolbox Container in Task Definition
+        id: render-toolbox
+        uses: aws-actions/amazon-ecs-render-task-definition@v1
+        with:
+          task-definition: ${{ steps.render-app.outputs.task-definition }}
+          container-name: mcp-toolbox
+          image: ${{ needs.build-and-push.outputs.toolbox-image }}
+
+      - name: Print Final Rendered Task Definition
+        run: cat ${{ steps.render-toolbox.outputs.task-definition }}
+
+      - name: Deploy to ECS
+        uses: aws-actions/amazon-ecs-deploy-task-definition@v1
+        with:
+          task-definition: ${{ steps.render-toolbox.outputs.task-definition }}
+          service: ${{ env.ECS_SERVICE }}
+          cluster: ${{ env.ECS_CLUSTER }}
+          wait-for-service-stability: true
+
+      - name: Done!
+        run: echo "Deployed to ECS Fargate Successfully with both containers!"

.github/workflows/ci.yaml

@@ -0,0 +1,64 @@
+name: Run Unit Tests
+
+on: [push, pull_request]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@v3
+
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.11.5'
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r requirements.txt
+          pip install pytest
+
+      - name: Setup Google Cloud credentials
+        env:
+          GOOGLE_API_KEY: ${{ secrets.GOOGLE_API_KEY }}
+          GOOGLE_APPLICATION_CREDENTIALS: ${{ secrets.GOOGLE_APPLICATION_CREDENTIALS }}
+        run: |
+
+          # If GOOGLE_API_KEY is provided
+          if [ ! -z "$GOOGLE_API_KEY" ]; then
+            echo "GOOGLE_API_KEY is configured"
+            echo "GOOGLE_API_KEY=$GOOGLE_API_KEY" >> $GITHUB_ENV
+          fi
+
+      - name: Setup other environment variables
+        env:
+          CHROMA_API_KEY: ${{ secrets.CHROMA_API_KEY }}
+          CHROMA_TENANT: ${{ secrets.CHROMA_TENANT }}
+          CHROMA_DATABASE: ${{ secrets.CHROMA_DATABASE }}
+          COINGECKO_API_KEY: ${{ secrets.COINGECKO_API_KEY }}
+          ALPHA_VANTAGE_API_KEY: ${{ secrets.ALPHA_VANTAGE_API_KEY }}
+        run: |
+          # Set ChromaDB credentials if available
+          if [ ! -z "$CHROMA_API_KEY" ]; then
+            echo "CHROMA_API_KEY=$CHROMA_API_KEY" >> $GITHUB_ENV
+          fi
+          if [ ! -z "$CHROMA_TENANT" ]; then
+            echo "CHROMA_TENANT=$CHROMA_TENANT" >> $GITHUB_ENV
+          fi
+          if [ ! -z "$CHROMA_DATABASE" ]; then
+            echo "CHROMA_DATABASE=$CHROMA_DATABASE" >> $GITHUB_ENV
+          fi
+
+          # Set other API keys if available
+          if [ ! -z "$COINGECKO_API_KEY" ]; then
+            echo "COINGECKO_API_KEY=$COINGECKO_API_KEY" >> $GITHUB_ENV
+          fi
+          if [ ! -z "$ALPHA_VANTAGE_API_KEY" ]; then
+            echo "ALPHA_VANTAGE_API_KEY=$ALPHA_VANTAGE_API_KEY" >> $GITHUB_ENV
+          fi
+          
+      - name: Run unit tests
+        run: |
+          pytest tests/

.github/workflows/task_definition.json

@@ -0,0 +1,156 @@
+{
+  "family": "multi-agent-app",
+  "networkMode": "awsvpc",
+  "requiresCompatibilities": ["FARGATE"],
+  "cpu": "1024",
+  "memory": "2048",
+  "executionRoleArn": "arn:aws:iam::730335436231:role/ecsTaskExecutionRole",
+  "taskRoleArn": "arn:aws:iam::730335436231:role/ecsTaskRole",
+  "containerDefinitions": [
+    {
+      "name": "multi-agent-app",
+      "image": "730335436231.dkr.ecr.eu-west-3.amazonaws.com/multi-agent-app",
+      "essential": true,
+      "portMappings": [
+        {
+          "containerPort": 8501,
+          "protocol": "tcp",
+          "name": "streamlit"
+        },
+        {
+          "containerPort": 8000,
+          "protocol": "tcp",
+          "name": "fastapi"
+        }
+      ],
+      "environment": [
+        {
+          "name": "ENV",
+          "value": "production"
+        },
+        {
+          "name": "API_BASE_URL",
+          "value": "http://localhost:8000"
+        },
+        {
+          "name": "MCP_TOOLBOX_SERVER_URL",
+          "value": "http://localhost:5000"
+        }
+      ],
+      "secrets": [
+        {
+          "name": "GOOGLE_API_KEY",
+          "valueFrom": "arn:aws:secretsmanager:eu-west-3:730335436231:secret:API_KEYS-VM91-fuw8iR:GOOGLE_API_KEY::"
+        },
+        {
+          "name": "ALPHA_VANTAGE_API_KEY",
+          "valueFrom": "arn:aws:secretsmanager:eu-west-3:730335436231:secret:API_KEYS-VM91-fuw8iR:ALPHA_VANTAGE_API_KEY::"
+        },
+        {
+          "name": "COINGECKO_API_KEY",
+          "valueFrom": "arn:aws:secretsmanager:eu-west-3:730335436231:secret:API_KEYS-VM91-fuw8iR:COINGECKO_API_KEY::"
+        },
+        {
+          "name": "CHROMA_API_KEY",
+          "valueFrom": "arn:aws:secretsmanager:eu-west-3:730335436231:secret:API_KEYS-VM91-fuw8iR:CHROMA_API_KEY::"
+        },
+        {
+          "name": "CHROMA_TENANT",
+          "valueFrom": "arn:aws:secretsmanager:eu-west-3:730335436231:secret:API_KEYS-VM91-fuw8iR:CHROMA_TENANT::"
+        },
+        {
+          "name": "CHROMA_DATABASE",
+          "valueFrom": "arn:aws:secretsmanager:eu-west-3:730335436231:secret:API_KEYS-VM91-fuw8iR:CHROMA_DATABASE::"
+        },
+        {
+          "name": "GCP_PROJECT_ID",
+          "valueFrom": "arn:aws:secretsmanager:eu-west-3:730335436231:secret:API_KEYS-VM91-fuw8iR:GCP_PROJECT_ID::"
+        },
+        {
+          "name": "CLOUD_SQL_REGION",
+          "valueFrom": "arn:aws:secretsmanager:eu-west-3:730335436231:secret:API_KEYS-VM91-fuw8iR:CLOUD_SQL_REGION::"
+        },
+        {
+          "name": "CLOUD_SQL_INSTANCE",
+          "valueFrom": "arn:aws:secretsmanager:eu-west-3:730335436231:secret:API_KEYS-VM91-fuw8iR:CLOUD_SQL_INSTANCE::"
+        },
+        {
+          "name": "CLOUD_SQL_DB_NAME",
+          "valueFrom": "arn:aws:secretsmanager:eu-west-3:730335436231:secret:API_KEYS-VM91-fuw8iR:CLOUD_SQL_DB_NAME::"
+        },
+        {
+          "name": "CLOUD_SQL_DB_USER",
+          "valueFrom": "arn:aws:secretsmanager:eu-west-3:730335436231:secret:API_KEYS-VM91-fuw8iR:CLOUD_SQL_DB_USER::"
+        },
+        {
+          "name": "CLOUD_SQL_DB_PASS",
+          "valueFrom": "arn:aws:secretsmanager:eu-west-3:730335436231:secret:API_KEYS-VM91-fuw8iR:CLOUD_SQL_DB_PASS::"
+        }
+      ],
+      "dependsOn": [
+        {
+          "containerName": "mcp-toolbox",
+          "condition": "START"
+        }
+      ],
+      "logConfiguration": {
+        "logDriver": "awslogs",
+        "options": {
+          "awslogs-group": "/ecs/multi-agent-app",
+          "awslogs-region": "eu-west-3",
+          "awslogs-stream-prefix": "ecs"
+        }
+      }
+    },
+    {
+      "name": "mcp-toolbox",
+      "image": "730335436231.dkr.ecr.eu-west-3.amazonaws.com/mcp-toolbox",
+      "essential": false,
+      "portMappings": [
+        {
+          "containerPort": 5000,
+          "protocol": "tcp",
+          "name": "mcp-toolbox"
+        }
+      ],
+      "secrets": [
+        {
+          "name": "GCP_SERVICE_ACCOUNT_JSON",
+          "valueFrom": "arn:aws:secretsmanager:eu-west-3:730335436231:secret:API_KEYS-VM91-fuw8iR:GCP_SERVICE_ACCOUNT_JSON::"
+        },
+        {
+          "name": "CLOUD_SQL_POSTGRES_PROJECT",
+          "valueFrom": "arn:aws:secretsmanager:eu-west-3:730335436231:secret:API_KEYS-VM91-fuw8iR:GCP_PROJECT_ID::"
+        },
+        {
+          "name": "CLOUD_SQL_POSTGRES_REGION",
+          "valueFrom": "arn:aws:secretsmanager:eu-west-3:730335436231:secret:API_KEYS-VM91-fuw8iR:CLOUD_SQL_REGION::"
+        },
+        {
+          "name": "CLOUD_SQL_POSTGRES_INSTANCE",
+          "valueFrom": "arn:aws:secretsmanager:eu-west-3:730335436231:secret:API_KEYS-VM91-fuw8iR:CLOUD_SQL_INSTANCE::"
+        },
+        {
+          "name": "CLOUD_SQL_POSTGRES_DATABASE",
+          "valueFrom": "arn:aws:secretsmanager:eu-west-3:730335436231:secret:API_KEYS-VM91-fuw8iR:CLOUD_SQL_DB_NAME::"
+        },
+        {
+          "name": "CLOUD_SQL_POSTGRES_USER",
+          "valueFrom": "arn:aws:secretsmanager:eu-west-3:730335436231:secret:API_KEYS-VM91-fuw8iR:CLOUD_SQL_DB_USER::"
+        },
+        {
+          "name": "CLOUD_SQL_POSTGRES_PASSWORD",
+          "valueFrom": "arn:aws:secretsmanager:eu-west-3:730335436231:secret:API_KEYS-VM91-fuw8iR:CLOUD_SQL_DB_PASS::"
+        }
+      ],
+      "logConfiguration": {
+        "logDriver": "awslogs",
+        "options": {
+          "awslogs-group": "/ecs/mcp-toolbox",
+          "awslogs-region": "eu-west-3",
+          "awslogs-stream-prefix": "ecs"
+        }
+      }
+    }
+  ]
+}

.gitignore

@@ -0,0 +1,59 @@
+# 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
+
+# Virtual environments
+venv/
+env/
+ENV/
+env.bak/
+venv.bak/
+
+# IDEs
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Gradio
+gradio_queue.db
+
+# Streamlit
+.streamlit/secrets.toml
+
+# Logs
+*.log
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+
+# Jupyter Notebook
+.ipynb_checkpoints

.streamlit/config.toml

@@ -0,0 +1,13 @@
+[theme]
+base="dark"
+primaryColor="#FF4B4B"
+backgroundColor="#0E1117"
+secondaryBackgroundColor="#262730"
+textColor="#FAFAFA"
+
+[server]
+headless = true
+port = 8501
+address = "0.0.0.0"
+enableCORS = false
+enableXsrfProtection = true

Dockerfile

@@ -0,0 +1,60 @@
+# Dockerfile for Hugging Face Spaces - Gradio Multi-Agent Assistant
+# This deploys the complete multi-agent system with Gradio UI
+
+FROM python:3.11-slim
+
+# Install system dependencies including Node.js for MCP servers
+RUN apt-get update && apt-get install -y \
+    ca-certificates \
+    curl \
+    git \
+    build-essential \
+    && curl -fsSL https://deb.nodesource.com/setup_20.x | bash - \
+    && apt-get install -y nodejs \
+    && rm -rf /var/lib/apt/lists/*
+
+# Verify installations
+RUN python --version && node --version && npm --version
+
+# Set working directory
+WORKDIR /app
+
+# Copy requirements first (for layer caching)
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+# Install npx-based MCP servers globally
+# CoinGecko MCP server for crypto data
+RUN npm install -g @coingecko/coingecko-mcp
+
+# Install uvx for Python-based MCP servers
+RUN pip install --no-cache-dir uv
+
+# Copy application code
+COPY src/ ./src/
+COPY ui/ ./ui/
+
+# Create directory for temporary file uploads
+RUN mkdir -p /tmp/uploads && chmod 777 /tmp/uploads
+
+# Copy entrypoint script
+COPY docker/entrypoint-hf.sh /app/entrypoint.sh
+RUN chmod +x /app/entrypoint.sh
+
+# Set environment variables for Hugging Face Spaces
+ENV GRADIO_SERVER_NAME="0.0.0.0" \
+    GRADIO_SERVER_PORT="7860" \
+    PYTHONUNBUFFERED=1
+
+# Expose Gradio port (HF Spaces expects 7860)
+EXPOSE 7860
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=90s --retries=3 \
+    CMD curl -f http://localhost:7860/ || exit 1
+
+# Run Gradio app via entrypoint
+CMD ["/app/entrypoint.sh"]

OLD/decision_maker.py

@@ -0,0 +1,104 @@
+"""Decision Maker to route queries to appropriate agents."""
+from typing import Any, Dict, List, Optional
+
+from config import config
+from langchain_google_genai import ChatGoogleGenerativeAI
+
+
+class DecisionMaker:
+    """LLM-based decision maker to route queries to appropriate agents."""
+    
+    def __init__(self):
+        self.name = "Decision Maker"
+        self.model = ChatGoogleGenerativeAI(
+            model="gemini-2.5-pro",
+            temperature=0.1,
+            google_api_key=config.GOOGLE_API_KEY,
+        )
+        
+        self.agent_descriptions = {
+            "crypto": """
+            Crypto Agent: Specializes in cryptocurrency market data, prices, trends, 
+            market analysis, and blockchain information. Use this for queries about:
+            - Cryptocurrency prices and market data
+            - Trading volumes and market caps
+            - Trending coins and top gainers/losers
+            - Blockchain statistics
+            - Crypto market analysis
+            """,
+            "rag": """
+            RAG Agent: Specializes in document retrieval and question answering from
+            uploaded documents (PDF, TXT, DOCX) stored in ChromaDB Cloud. Use this for queries about:
+            - Questions about uploaded documents
+            - Information retrieval from your document library
+            - Document search and semantic analysis
+            - Knowledge base queries
+            - Content from stored files
+            - Finding specific information in documents
+            """
+        }
+    
+    async def decide_agent(self, query: str, history: Optional[List[Dict[str, str]]] = None) -> Dict[str, Any]:
+        """Decide which agent should handle the query."""
+        try:
+            history_block = ""
+            if history:
+                recent_history = history[-6:]
+                history_lines: List[str] = []
+                for turn in recent_history:
+                    user_text = turn.get("user", "").strip()
+                    if user_text:
+                        history_lines.append(f"User: {user_text}")
+                    assistant_text = turn.get("assistant", "").strip()
+                    if assistant_text:
+                        history_lines.append(f"Assistant: {assistant_text}")
+                if history_lines:
+                    history_block = "Recent conversation:\n" + "\n".join(history_lines) + "\n\n"
+
+            prompt = f"""You are a routing system for a multi-agent AI application.
+
+{history_block}Available agents:
+{self.agent_descriptions['crypto']}
+
+{self.agent_descriptions['rag']}
+
+User query: "{query}"
+
+Analyze the query and determine which agent should handle it.
+Respond with ONLY a JSON object in this exact format:
+{{
+    "agent": "crypto" or "rag",
+    "confidence": 0.0-1.0,
+    "reasoning": "brief explanation"
+}}
+
+Choose carefully based on the query content."""
+
+            response = await self.model.ainvoke(prompt)
+            result_text = response.content.strip() if isinstance(response.content, str) else str(response.content)
+
+            # Extract JSON from response
+            import json
+            # Remove markdown code blocks if present
+            if "```json" in result_text:
+                result_text = result_text.split("```json")[1].split("```")[0].strip()
+            elif "```" in result_text:
+                result_text = result_text.split("```")[1].split("```")[0].strip()
+
+            decision = json.loads(result_text)
+
+            print(f"\n🎯 {self.name} Decision:")
+            print(f"  Agent: {decision['agent']}")
+            print(f"  Confidence: {decision['confidence']}")
+            print(f"  Reasoning: {decision['reasoning']}")
+
+            return decision
+
+        except Exception as e:
+            print(f"❌ Error in decision maker: {e}")
+            # Default to crypto agent if decision fails
+            return {
+                "agent": "crypto",
+                "confidence": 0.5,
+                "reasoning": f"Error in decision maker, defaulting to crypto agent: {str(e)}"
+            }

OLD/misc/rag_docker.py

@@ -0,0 +1,172 @@
+"""RAG Agent using Chroma MCP Server via LangChain MCP adapters."""
+import json
+import os
+import shutil
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from config import config
+from file_processors import process_document
+from langchain_core.tools import BaseTool
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_mcp_adapters.client import MultiServerMCPClient
+
+
+class RAGAgentMCP:
+    """Agent specialized in document retrieval and Q&A using Chroma MCP Server."""
+
+    @staticmethod
+    def _to_text(payload: Any) -> str:
+        """Convert tool or model output into a displayable string."""
+        if isinstance(payload, str):
+            return payload
+        try:
+            return json.dumps(payload, ensure_ascii=False)
+        except TypeError:
+            return str(payload)
+
+    def __init__(self):
+        self.name = "RAG Agent (MCP)"
+        self.description = "Document storage, retrieval, and question answering expert using Chroma MCP Server"
+        self.mcp_client: Optional[MultiServerMCPClient] = None
+        self.model: Optional[ChatGoogleGenerativeAI] = None
+        self.tools: List[BaseTool] = []
+        self.tool_map: Dict[str, BaseTool] = {}
+
+    async def initialize(self) -> None:
+        """Initialize the agent with Chroma MCP server."""
+        print(f"🔧 Initializing {self.name}...")
+
+        try:
+            # Connect to Chroma MCP Server for tool access
+            print(f"  📡 Connecting to Chroma MCP Server...")
+            chroma_connection = self._build_chroma_connection()
+            self.mcp_client = MultiServerMCPClient({"chroma": chroma_connection})
+
+            # Get tools from MCP server
+            self.tools = await self.mcp_client.get_tools(server_name="chroma")
+            if not self.tools:
+                raise RuntimeError("No tools returned by Chroma MCP server")
+
+            self.tool_map = {tool.name: tool for tool in self.tools}
+
+            print(f"  ✅ Connected to Chroma MCP Server with {len(self.tools)} tools")
+
+            # Initialize Gemini model for answer generation
+            self.model = ChatGoogleGenerativeAI(
+                model="gemini-2.5-flash",
+                temperature=0.1,
+                google_api_key=config.GOOGLE_API_KEY,
+            )
+
+            print(f"  ✅ {self.name} ready!")
+
+        except Exception as e:
+            import traceback
+            print(f"  ❌ Error initializing {self.name}: {e}")
+            print(f"  📋 Full error details:")
+            traceback.print_exc()
+            raise
+
+    async def add_document(
+        self,
+        file_path: str,
+        metadata: Optional[Dict[str, Any]] = None,
+        progress_callback: Optional[callable] = None
+    ) -> Dict[str, Any]:
+        """Add a document to ChromaDB via MCP server."""
+        try:
+            doc_path = Path(file_path)
+
+            # Validate file type
+            if doc_path.suffix.lower() not in config.ALLOWED_FILE_TYPES:
+                return {
+                    "success": False,
+                    "error": f"Unsupported file type: {doc_path.suffix}. Allowed: {config.ALLOWED_FILE_TYPES}"
+                }
+
+            print(f"\n📄 Processing {doc_path.suffix.upper()}: {doc_path.name}")
+
+            if progress_callback:
+                progress_callback(0.1, "Extracting text from document...")
+
+            # Process document using file_processors
+            doc_info = process_document(doc_path, chunk_size=500, overlap=50)
+
+            if progress_callback:
+                progress_callback(0.4, f"Extracted {doc_info['num_chunks']} chunks...")
+
+            # Generate document ID
+            doc_id = doc_path.stem
+
+            # Prepare metadata
+            doc_metadata = {
+                "filename": doc_info["filename"],
+                "file_type": doc_info["file_type"],
+                "file_size": doc_info["file_size"],
+                "num_chunks": doc_info["num_chunks"],
+                "source": "user_upload",
+                **(metadata or {})
+            }
+
+            # Upload via Chroma MCP Server
+            if progress_callback:
+                progress_callback(0.6, "Uploading via Chroma MCP Server...")
+
+            # Prepare data for MCP add_documents tool
+            chunks = doc_info["chunks"]
+            ids = [f"{doc_id}_chunk_{i}" for i in range(len(chunks))]
+            metadatas = [
+                {**doc_metadata, "chunk_index": i, "chunk_id": ids[i]}
+                for i in range(len(chunks))
+            ]
+
+            add_tool = (
+                self.tool_map.get("chroma_add_documents")
+                or self.tool_map.get("add_documents")
+            )
+            if not add_tool:
+                raise KeyError("add_documents tool not available in Chroma MCP")
+
+            tool_payload = {
+                "collection_name": "gemini-embed",  # Use dedicated Gemini collection
+                "documents": chunks,
+                "ids": ids,
+                "metadatas": metadatas,
+            }
+
+            result = await add_tool.ainvoke(tool_payload)
+
+            if isinstance(result, dict) and result.get("success"):
+                print(f"  ✅ Added via MCP: {len(chunks)} chunks from {doc_path.name}")
+            else:
+                raise ValueError(result)
+
+            if progress_callback:
+                progress_callback(1.0, "Upload complete!")
+
+            return {
+                "success": True,
+                "document_id": doc_id,
+                "filename": doc_path.name,
+                "file_type": doc_info["file_type"],
+                "chunks_added": len(chunks),
+            }
+
+        except Exception as e:
+            print(f"  ❌ Error adding document: {e}")
+            import traceback
+            traceback.print_exc()
+            return {
+                "success": False,
+                "error": str(e)
+            }
+
+    def _build_chroma_connection(self) -> Dict[str, Any]:
+        """Create connection configuration for the Chroma MCP server."""
+        return {
+            "transport": "docker",
+            "command": "mcp",
+            "args": ["gateway", "run", "--servers=chromadb"],
+        }

OLD/searchagent_ddg_api.py

@@ -0,0 +1,261 @@
+"""DuckDuckGo Search Agent for web search capabilities."""
+import asyncio
+from typing import Dict, Any, Optional, List
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_core.messages import HumanMessage, SystemMessage
+from ddgs import DDGS
+from config import config
+
+
+class SearchAgentMCP:
+    """
+    Agent for performing web searches using DuckDuckGo.
+    Follows the same pattern as other MCP agents in the system.
+    """
+
+    def __init__(self):
+        """Initialize the DuckDuckGo search agent."""
+        self.llm = None
+        self.ddgs = DDGS()
+        self.initialized = False
+
+    async def initialize(self):
+        """Initialize the agent with LLM."""
+        if not self.initialized:
+            self.llm = ChatGoogleGenerativeAI(
+                model="gemini-2.5-flash",
+                temperature=0.3,
+                google_api_key=config.GOOGLE_API_KEY,
+            )
+            self.initialized = True
+            print("✅ Search Agent initialized")
+
+    async def search_web(
+        self,
+        query: str,
+        max_results: int = 4,
+        region: str = "wt-wt"
+    ) -> Dict[str, Any]:
+        """
+        Perform a web search using DuckDuckGo.
+
+        Args:
+            query: Search query
+            max_results: Maximum number of results to return (default: 5)
+            region: Region for search (default: wt-wt for worldwide)
+
+        Returns:
+            Dictionary with search results
+        """
+        try:
+            # Perform search
+            results = []
+            # Pass query as positional argument (API changed in newer versions)
+            search_results = list(self.ddgs.text(
+                query,
+                region=region,
+                safesearch='moderate',
+                max_results=max_results
+            ))
+
+            for result in search_results:
+                results.append({
+                    "title": result.get("title", ""),
+                    "link": result.get("href", ""),
+                    "snippet": result.get("body", "")
+                })
+
+            return {
+                "success": True,
+                "query": query,
+                "results": results,
+                "count": len(results)
+            }
+
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e),
+                "query": query,
+                "results": []
+            }
+
+    async def search_news(
+        self,
+        query: str,
+        max_results: int = 4
+    ) -> Dict[str, Any]:
+        """
+        Search for news articles using DuckDuckGo.
+
+        Args:
+            query: Search query
+            max_results: Maximum number of results
+
+        Returns:
+            Dictionary with news results
+        """
+        try:
+            results = []
+            # Pass query as positional argument (API changed in newer versions)
+            news_results = list(self.ddgs.news(
+                query,
+                safesearch='moderate',
+                max_results=max_results
+            ))
+
+            for result in news_results:
+                results.append({
+                    "title": result.get("title", ""),
+                    "link": result.get("url", ""),
+                    "snippet": result.get("body", ""),
+                    "source": result.get("source", ""),
+                    "date": result.get("date", "")
+                })
+
+            return {
+                "success": True,
+                "query": query,
+                "results": results,
+                "count": len(results)
+            }
+
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e),
+                "query": query,
+                "results": []
+            }
+
+    def _format_search_results(self, search_data: Dict[str, Any]) -> str:
+        """
+        Format search results into a readable string.
+
+        Args:
+            search_data: Raw search results
+
+        Returns:
+            Formatted string of results
+        """
+        if not search_data.get("success"):
+            return f"Search failed: {search_data.get('error', 'Unknown error')}"
+
+        results = search_data.get("results", [])
+        if not results:
+            return f"No results found for query: {search_data.get('query')}"
+
+        formatted = f"Found {len(results)} results for '{search_data.get('query')}':\n\n"
+
+        for idx, result in enumerate(results, 1):
+            formatted += f"{idx}. {result.get('title', 'No title')}\n"
+            formatted += f"   URL: {result.get('link', 'N/A')}\n"
+            formatted += f"   {result.get('snippet', 'No description')}\n"
+            
+            # Add source and date for news results
+            if result.get('source'):
+                formatted += f"   Source: {result['source']}"
+                if result.get('date'):
+                    formatted += f" | Date: {result['date']}"
+                formatted += "\n"
+            
+            formatted += "\n"
+
+        return formatted
+
+    async def process(
+        self,
+        query: str,
+        history: Optional[List[Dict[str, str]]] = None
+    ) -> Dict[str, Any]:
+        """
+        Process a search query with LLM interpretation.
+
+        Args:
+            query: User's search query
+            history: Optional conversation history
+
+        Returns:
+            Dictionary with agent response
+        """
+        try:
+            if not self.initialized:
+                await self.initialize()
+
+            # Determine search type and execute
+            search_type = await self._determine_search_type(query)
+            
+            if search_type == "news":
+                search_results = await self.search_news(query, max_results=5)
+            else:
+                search_results = await self.search_web(query, max_results=5)
+
+            # Format results
+            formatted_results = self._format_search_results(search_results)
+
+            # Generate LLM response with context
+            system_prompt = """You are a web search assistant. Your role is to:
+1. Interpret web search results
+2. Synthesize information from multiple sources
+3. Provide clear, accurate answers with source attribution
+4. Highlight the most relevant findings
+5. Note any limitations or conflicting information
+
+Always cite sources by referring to their result numbers (e.g., "According to result #1...")."""
+
+            user_prompt = f"""User Query: {query}
+
+Search Results:
+{formatted_results}
+
+Based on these search results, provide a comprehensive answer to the user's query. 
+Include relevant details and cite your sources."""
+
+            response = await self.llm.ainvoke([
+                SystemMessage(content=system_prompt),
+                HumanMessage(content=user_prompt)
+            ])
+
+            return {
+                "success": True,
+                "response": response.content,
+                "raw_results": search_results,
+                "search_type": search_type,
+                "metadata": {
+                    "results_count": search_results.get("count", 0),
+                    "query": query
+                }
+            }
+
+        except Exception as e:
+            error_msg = f"Error processing search query: {str(e)}"
+            return {
+                "success": False,
+                "error": error_msg,
+                "response": f"I encountered an error while searching: {str(e)}"
+            }
+
+    async def _determine_search_type(self, query: str) -> str:
+        """
+        Determine if query is asking for news or general web search.
+
+        Args:
+            query: User query
+
+        Returns:
+            "news" or "web"
+        """
+        query_lower = query.lower()
+        news_keywords = ["news", "latest", "recent", "today", "breaking", "update"]
+        
+        if any(keyword in query_lower for keyword in news_keywords):
+            return "news"
+        
+        return "web"
+
+    async def cleanup(self):
+        """Cleanup resources."""
+        if self.initialized:
+            # DuckDuckGo search doesn't need explicit cleanup
+            self.initialized = False
+            print("🧹 Search Agent cleanup complete")

database_schema.sql

@@ -0,0 +1,177 @@
+CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
+
+-- Table: stock_transactions
+-- Stores all buy/sell transactions for the portfolio
+CREATE TABLE IF NOT EXISTS stock_transactions (
+    id SERIAL PRIMARY KEY,
+    transaction_id UUID DEFAULT uuid_generate_v4() UNIQUE NOT NULL,
+    symbol VARCHAR(10) NOT NULL,
+    transaction_type VARCHAR(10) NOT NULL CHECK (transaction_type IN ('BUY', 'SELL')),
+    quantity DECIMAL(15, 4) NOT NULL CHECK (quantity > 0),
+    price DECIMAL(15, 4) NOT NULL CHECK (price >= 0),
+    transaction_date DATE NOT NULL,
+    notes TEXT,
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Table: portfolio_positions
+-- Stores current aggregated positions (calculated from transactions)
+CREATE TABLE IF NOT EXISTS portfolio_positions (
+    symbol VARCHAR(10) PRIMARY KEY,
+    total_quantity DECIMAL(15, 4) NOT NULL CHECK (total_quantity >= 0),
+    avg_cost_basis DECIMAL(15, 4) NOT NULL CHECK (avg_cost_basis >= 0),
+    first_purchase_date DATE,
+    last_transaction_date DATE,
+    total_invested DECIMAL(15, 2) NOT NULL DEFAULT 0,
+    realized_gains DECIMAL(15, 2) DEFAULT 0,
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Table: portfolio_snapshots
+-- Stores historical portfolio value snapshots for performance tracking
+CREATE TABLE IF NOT EXISTS portfolio_snapshots (
+    id SERIAL PRIMARY KEY,
+    snapshot_date DATE NOT NULL,
+    total_value DECIMAL(15, 2) NOT NULL,
+    total_cost_basis DECIMAL(15, 2) NOT NULL,
+    total_gain_loss DECIMAL(15, 2) NOT NULL,
+    total_gain_loss_pct DECIMAL(10, 4) NOT NULL,
+    num_positions INTEGER NOT NULL,
+    snapshot_data JSONB,  -- Store detailed position data
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Table: stock_metadata
+-- Cache stock information to reduce API calls
+CREATE TABLE IF NOT EXISTS stock_metadata (
+    symbol VARCHAR(10) PRIMARY KEY,
+    company_name VARCHAR(255),
+    sector VARCHAR(100),
+    industry VARCHAR(100),
+    market_cap BIGINT,
+    last_updated TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Indexes for performance optimization
+CREATE INDEX IF NOT EXISTS idx_transactions_symbol ON stock_transactions(symbol);
+CREATE INDEX IF NOT EXISTS idx_transactions_date ON stock_transactions(transaction_date DESC);
+CREATE INDEX IF NOT EXISTS idx_transactions_type ON stock_transactions(transaction_type);
+CREATE INDEX IF NOT EXISTS idx_snapshots_date ON portfolio_snapshots(snapshot_date DESC);
+CREATE INDEX IF NOT EXISTS idx_stock_metadata_sector ON stock_metadata(sector);
+
+-- Function to update the updated_at timestamp
+CREATE OR REPLACE FUNCTION update_updated_at_column()
+RETURNS TRIGGER AS $$
+BEGIN
+    NEW.updated_at = CURRENT_TIMESTAMP;
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+-- Triggers to automatically update updated_at
+CREATE TRIGGER update_stock_transactions_updated_at
+    BEFORE UPDATE ON stock_transactions
+    FOR EACH ROW
+    EXECUTE FUNCTION update_updated_at_column();
+
+CREATE TRIGGER update_portfolio_positions_updated_at
+    BEFORE UPDATE ON portfolio_positions
+    FOR EACH ROW
+    EXECUTE FUNCTION update_updated_at_column();
+
+CREATE TRIGGER update_stock_metadata_updated_at
+    BEFORE UPDATE ON stock_metadata
+    FOR EACH ROW
+    EXECUTE FUNCTION update_updated_at_column();
+
+-- Function to recalculate portfolio positions
+-- This ensures positions are always in sync with transactions
+CREATE OR REPLACE FUNCTION recalculate_position(p_symbol VARCHAR)
+RETURNS VOID AS $$
+DECLARE
+    v_total_quantity DECIMAL(15, 4);
+    v_avg_cost_basis DECIMAL(15, 4);
+    v_total_invested DECIMAL(15, 2);
+    v_realized_gains DECIMAL(15, 2);
+    v_first_purchase DATE;
+    v_last_transaction DATE;
+BEGIN
+    -- Calculate position from transactions
+    WITH position_calc AS (
+        SELECT
+            SUM(CASE WHEN transaction_type = 'BUY' THEN quantity ELSE -quantity END) as net_quantity,
+            SUM(CASE WHEN transaction_type = 'BUY' THEN quantity * price ELSE 0 END) as total_cost,
+            SUM(CASE WHEN transaction_type = 'BUY' THEN quantity ELSE 0 END) as total_bought,
+            MIN(CASE WHEN transaction_type = 'BUY' THEN transaction_date END) as first_buy,
+            MAX(transaction_date) as last_trans,
+            SUM(CASE WHEN transaction_type = 'SELL' THEN quantity * price ELSE 0 END) -
+            SUM(CASE WHEN transaction_type = 'SELL' THEN quantity *
+                (SELECT AVG(price) FROM stock_transactions WHERE symbol = p_symbol AND transaction_type = 'BUY')
+                ELSE 0 END) as realized_gain
+        FROM stock_transactions
+        WHERE symbol = p_symbol
+    )
+    SELECT
+        net_quantity,
+        CASE WHEN total_bought > 0 THEN total_cost / total_bought ELSE 0 END,
+        total_cost,
+        COALESCE(realized_gain, 0),
+        first_buy,
+        last_trans
+    INTO v_total_quantity, v_avg_cost_basis, v_total_invested, v_realized_gains, v_first_purchase, v_last_transaction
+    FROM position_calc;
+
+    -- Update or delete position
+    IF v_total_quantity > 0 THEN
+        INSERT INTO portfolio_positions (
+            symbol, total_quantity, avg_cost_basis, total_invested,
+            realized_gains, first_purchase_date, last_transaction_date
+        )
+        VALUES (
+            p_symbol, v_total_quantity, v_avg_cost_basis, v_total_invested,
+            v_realized_gains, v_first_purchase, v_last_transaction
+        )
+        ON CONFLICT (symbol) DO UPDATE SET
+            total_quantity = EXCLUDED.total_quantity,
+            avg_cost_basis = EXCLUDED.avg_cost_basis,
+            total_invested = EXCLUDED.total_invested,
+            realized_gains = EXCLUDED.realized_gains,
+            first_purchase_date = EXCLUDED.first_purchase_date,
+            last_transaction_date = EXCLUDED.last_transaction_date;
+    ELSE
+        -- If position is fully closed, delete it
+        DELETE FROM portfolio_positions WHERE symbol = p_symbol;
+    END IF;
+END;
+$$ LANGUAGE plpgsql;
+
+-- Trigger to automatically recalculate positions when transactions change
+CREATE OR REPLACE FUNCTION trigger_recalculate_position()
+RETURNS TRIGGER AS $$
+BEGIN
+    IF TG_OP = 'DELETE' THEN
+        PERFORM recalculate_position(OLD.symbol);
+        RETURN OLD;
+    ELSE
+        PERFORM recalculate_position(NEW.symbol);
+        RETURN NEW;
+    END IF;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE TRIGGER auto_recalculate_position
+    AFTER INSERT OR UPDATE OR DELETE ON stock_transactions
+    FOR EACH ROW
+    EXECUTE FUNCTION trigger_recalculate_position();
+
+-- View: current_portfolio_summary
+-- Provides a quick overview of the portfolio
+CREATE OR REPLACE VIEW current_portfolio_summary AS
+SELECT
+    COUNT(*) as total_positions,
+    SUM(total_quantity) as total_shares,
+    SUM(total_invested) as total_invested,
+    SUM(realized_gains) as total_realized_gains
+FROM portfolio_positions;

docker-compose.yml

@@ -0,0 +1,93 @@
+version: '3.8'
+
+services:
+  # Main Multi-Agent Application (Streamlit UI + FastAPI Backend)
+  app:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    container_name: multi-agent-app
+    ports:
+      - "8501:8501"  # Streamlit UI
+      - "8000:8000"  # FastAPI Backend
+    environment:
+      # API Keys
+      GOOGLE_API_KEY: ${GOOGLE_API_KEY}
+      COINGECKO_API_KEY: ${COINGECKO_API_KEY}
+      ALPHA_VANTAGE_API_KEY: ${ALPHA_VANTAGE_API_KEY}
+
+      # ChromaDB Cloud Configuration
+      CHROMA_API_KEY: ${CHROMA_API_KEY}
+      CHROMA_TENANT: ${CHROMA_TENANT}
+      CHROMA_DATABASE: ${CHROMA_DATABASE}
+      CHROMA_CLOUD_HOST: ${CHROMA_CLOUD_HOST:-api.trychroma.com}
+      CHROMA_EMBEDDING_FUNCTION: ${CHROMA_EMBEDDING_FUNCTION:-default}
+      DOCUMENTS_COLLECTION: ${DOCUMENTS_COLLECTION:-mcp-test}
+
+      # Google Cloud SQL Configuration
+      GCP_PROJECT_ID: ${GCP_PROJECT_ID}
+      CLOUD_SQL_REGION: ${CLOUD_SQL_REGION}
+      CLOUD_SQL_INSTANCE: ${CLOUD_SQL_INSTANCE}
+      CLOUD_SQL_DB_NAME: ${CLOUD_SQL_DB_NAME:-finance_tracker}
+      CLOUD_SQL_DB_USER: ${CLOUD_SQL_DB_USER}
+      CLOUD_SQL_DB_PASS: ${CLOUD_SQL_DB_PASS}
+
+      # MCP Toolbox connection (internal network)
+      MCP_TOOLBOX_SERVER_URL: http://mcp-toolbox:5000
+
+      # UI Configuration
+      MAX_FILE_SIZE_MB: ${MAX_FILE_SIZE_MB:-50}
+
+    depends_on:
+      - mcp-toolbox
+
+    networks:
+      - mcp-network
+
+    restart: unless-stopped
+
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 90s
+
+  # MCP Toolbox for Cloud SQL Access
+  mcp-toolbox:
+    build:
+      context: .
+      dockerfile: Dockerfile.toolbox
+    container_name: mcp-toolbox-server
+    ports:
+      - "5000:5000"
+    environment:
+      # Cloud SQL Connection Details
+      CLOUD_SQL_POSTGRES_PROJECT: ${GCP_PROJECT_ID}
+      CLOUD_SQL_POSTGRES_REGION: ${CLOUD_SQL_REGION}
+      CLOUD_SQL_POSTGRES_INSTANCE: ${CLOUD_SQL_INSTANCE}
+      CLOUD_SQL_POSTGRES_DATABASE: ${CLOUD_SQL_DB_NAME}
+      CLOUD_SQL_POSTGRES_USER: ${CLOUD_SQL_DB_USER}
+      CLOUD_SQL_POSTGRES_PASSWORD: ${CLOUD_SQL_DB_PASS}
+
+      # Google Cloud credentials path (used by Cloud SQL connector)
+      GOOGLE_APPLICATION_CREDENTIALS: /app/credentials/credentials.json
+
+    volumes:
+      # Mount Application Default Credentials to the location MCP Toolbox expects
+      # Linux/Mac: ${HOME}/.config/gcloud/application_default_credentials.json
+      # Windows: ${APPDATA}/gcloud/application_default_credentials.json
+      - ${APPDATA}/gcloud/application_default_credentials.json:/app/credentials/credentials.json:ro
+
+    networks:
+      - mcp-network
+
+    restart: unless-stopped
+
+    # Note: MCP Toolbox doesn't expose a health endpoint
+    # Check if container is running with: docker-compose ps
+
+networks:
+  mcp-network:
+    name: mcp-toolbox-network
+    driver: bridge

docker/Dockerfile

@@ -0,0 +1,64 @@
+# Multi-stage Dockerfile for Multi-Agent Assistant
+# Supports both Python (uvx) and Node.js (npx) MCP servers
+
+FROM python:3.11-slim as base
+
+# Install system dependencies including Node.js
+RUN apt-get update && apt-get install -y \
+    ca-certificates \
+    curl \
+    git \
+    build-essential \
+    && curl -fsSL https://deb.nodesource.com/setup_20.x | bash - \
+    && apt-get install -y nodejs \
+    && rm -rf /var/lib/apt/lists/*
+
+# Verify installations
+RUN python --version && node --version && npm --version
+
+# Set working directory
+WORKDIR /app
+
+# Copy requirements first (for layer caching)
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+# Install npx-based MCP servers globally (for CoinGecko)
+RUN npm install -g @coingecko/coingecko-mcp
+
+# Copy application code with new structure
+COPY src/ ./src/
+COPY ui/ ./ui/
+COPY tests/ ./tests/
+
+# Copy startup script
+COPY scripts/start.sh ./start.sh
+
+# Create directory for temporary file uploads
+RUN mkdir -p /tmp/uploads && chmod 777 /tmp/uploads
+
+# Make startup script executable
+RUN chmod +x /app/start.sh
+
+# Copy Streamlit config (includes dark theme)
+RUN mkdir -p /root/.streamlit
+COPY .streamlit/config.toml /root/.streamlit/config.toml
+
+# Additional Streamlit config for production
+RUN echo '\n[browser]\ngatherUsageStats = false\n' >> /root/.streamlit/config.toml
+
+
+# Expose ports
+# 8501 - Streamlit UI
+# 8000 - FastAPI Backend
+EXPOSE 8501 8000
+
+# Health check - check both FastAPI and Streamlit
+HEALTHCHECK --interval=30s --timeout=10s --start-period=90s --retries=3 \
+    CMD curl -f http://localhost:8000/health && curl -f http://localhost:8501/_stcore/health || exit 1
+
+# Use startup script to run both FastAPI and Streamlit
+CMD ["/app/start.sh"]

docker/Dockerfile.toolbox

@@ -0,0 +1,52 @@
+# Dockerfile for MCP Toolbox Server
+# Runs MCP Toolbox as an HTTP server for Cloud SQL PostgreSQL access
+
+FROM debian:bookworm-slim
+
+# Install dependencies
+RUN apt-get update && apt-get install -y \
+    ca-certificates \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set MCP Toolbox version
+ARG TOOLBOX_VERSION=v0.18.0
+
+# Detect architecture and download appropriate binary
+RUN ARCH=$(dpkg --print-architecture) && \
+    if [ "$ARCH" = "amd64" ]; then \
+        TOOLBOX_ARCH="amd64"; \
+    elif [ "$ARCH" = "arm64" ]; then \
+        TOOLBOX_ARCH="arm64"; \
+    else \
+        echo "Unsupported architecture: $ARCH" && exit 1; \
+    fi && \
+    curl -L "https://storage.googleapis.com/genai-toolbox/${TOOLBOX_VERSION}/linux/${TOOLBOX_ARCH}/toolbox" \
+        -o /usr/local/bin/toolbox && \
+    chmod +x /usr/local/bin/toolbox
+
+# Verify installation
+RUN toolbox --version
+
+# Create credentials directory
+RUN mkdir -p /app/credentials
+
+# Copy entrypoint script
+COPY docker/entrypoint-toolbox.sh /entrypoint.sh
+RUN chmod +x /entrypoint.sh
+
+# Expose port for HTTP server
+EXPOSE 5000
+
+# Environment variables for Cloud SQL connection
+# These will be provided via docker-compose or docker run
+ENV CLOUD_SQL_POSTGRES_PROJECT="" \
+    CLOUD_SQL_POSTGRES_REGION="" \
+    CLOUD_SQL_POSTGRES_INSTANCE="" \
+    CLOUD_SQL_POSTGRES_DATABASE="" \
+    CLOUD_SQL_POSTGRES_USER="" \
+    CLOUD_SQL_POSTGRES_PASSWORD="" \
+    GCP_SERVICE_ACCOUNT_JSON=""
+
+# Run MCP Toolbox via entrypoint script (handles GCP credentials)
+ENTRYPOINT ["/entrypoint.sh"]

docker/entrypoint-hf.sh

@@ -0,0 +1,55 @@
+#!/bin/bash
+# Entrypoint script for Hugging Face Spaces deployment
+# Launches the Gradio multi-agent assistant
+
+set -e
+
+echo "=================================================="
+echo "🚀 Starting PortfolioMind Multi-Agent Assistant"
+echo "=================================================="
+
+# Validate required environment variables
+echo "📋 Validating configuration..."
+
+REQUIRED_VARS=(
+    "GOOGLE_API_KEY"
+    "CHROMA_API_KEY"
+    "CHROMA_TENANT"
+    "CHROMA_DATABASE"
+    "ALPHA_VANTAGE_API_KEY"
+)
+
+MISSING_VARS=()
+for var in "${REQUIRED_VARS[@]}"; do
+    if [ -z "${!var}" ]; then
+        MISSING_VARS+=("$var")
+    fi
+done
+
+if [ ${#MISSING_VARS[@]} -gt 0 ]; then
+    echo "❌ Missing required environment variables:"
+    for var in "${MISSING_VARS[@]}"; do
+        echo "   - $var"
+    done
+    echo ""
+    echo "Please configure these in Hugging Face Space Settings > Variables and Secrets"
+    exit 1
+fi
+
+echo "✅ All required environment variables are set"
+
+# Optional variables (log if present)
+echo ""
+echo "📊 Optional services status:"
+[ -n "$COINGECKO_API_KEY" ] && echo "   ✓ CoinGecko API configured" || echo "   ⚠ CoinGecko API not configured (using free tier)"
+[ -n "$GCP_PROJECT_ID" ] && echo "   ✓ Google Cloud SQL configured" || echo "   ⚠ Google Cloud SQL not configured"
+[ -n "$MCP_TOOLBOX_SERVER_URL" ] && echo "   ✓ MCP Toolbox URL: $MCP_TOOLBOX_SERVER_URL" || echo "   ⚠ MCP Toolbox not configured"
+
+echo ""
+echo "🎯 Starting Gradio application on port 7860..."
+echo "=================================================="
+echo ""
+
+# Launch Gradio app
+cd /app
+exec python -u ui/gradio_app.py

docker/entrypoint-toolbox.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+set -e
+
+# Write GCP credentials from environment variable to file
+if [ -n "$GCP_SERVICE_ACCOUNT_JSON" ]; then
+    echo "Configuring GCP credentials from environment variable..."
+    mkdir -p /app/credentials
+    echo "$GCP_SERVICE_ACCOUNT_JSON" > /app/credentials/credentials.json
+    export GOOGLE_APPLICATION_CREDENTIALS=/app/credentials/credentials.json
+    echo "GCP credentials configured successfully"
+else
+    echo "WARNING: GCP_SERVICE_ACCOUNT_JSON not set. Cloud SQL authentication may fail."
+fi
+
+# Start MCP Toolbox
+echo "Starting MCP Toolbox server on port 5000..."
+exec toolbox --prebuilt cloud-sql-postgres --port 5000 --address 0.0.0.0

fastapi_testing.ipynb

@@ -0,0 +1,1209 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# FastAPI Multi-Agent System Testing\n",
+    "\n",
+    "This notebook demonstrates how to test and interact with the FastAPI endpoints.\n",
+    "\n",
+    "## Prerequisites\n",
+    "\n",
+    "Make sure the FastAPI server is running:\n",
+    "```bash\n",
+    "python api.py\n",
+    "# OR\n",
+    "uvicorn api:app --host 0.0.0.0 --port 8000 --reload\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Setup and Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "✅ Imports successful\n",
+      "🌐 API Base URL: http://localhost:8000\n"
+     ]
+    }
+   ],
+   "source": [
+    "import requests\n",
+    "import json\n",
+    "import asyncio\n",
+    "import websockets\n",
+    "from pathlib import Path\n",
+    "import time\n",
+    "from IPython.display import display, Markdown, HTML\n",
+    "\n",
+    "# API Base URL\n",
+    "BASE_URL = \"http://localhost:8000\"\n",
+    "\n",
+    "print(\"✅ Imports successful\")\n",
+    "print(f\"🌐 API Base URL: {BASE_URL}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1. Health Check\n",
+    "\n",
+    "Test if the API is running and all agents are initialized."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "🏥 Health Check Response:\n",
+      "  Status: healthy\n",
+      "  Initialized: True\n",
+      "\n",
+      "  Agent Status:\n",
+      "    ✅ crypto: True\n",
+      "    ✅ rag: True\n",
+      "    ✅ stock: True\n",
+      "    ✅ search: True\n",
+      "    ✅ finance_tracker: True\n"
+     ]
+    }
+   ],
+   "source": [
+    "def test_health_check():\n",
+    "    \"\"\"Test the health check endpoint.\"\"\"\n",
+    "    try:\n",
+    "        response = requests.get(f\"{BASE_URL}/health\")\n",
+    "        response.raise_for_status()\n",
+    "        data = response.json()\n",
+    "        \n",
+    "        print(\"🏥 Health Check Response:\")\n",
+    "        print(f\"  Status: {data['status']}\")\n",
+    "        print(f\"  Initialized: {data['initialized']}\")\n",
+    "        print(\"\\n  Agent Status:\")\n",
+    "        for agent, status in data['agents'].items():\n",
+    "            emoji = \"✅\" if status else \"❌\"\n",
+    "            print(f\"    {emoji} {agent}: {status}\")\n",
+    "        \n",
+    "        return data\n",
+    "    except Exception as e:\n",
+    "        print(f\"❌ Error: {e}\")\n",
+    "        return None\n",
+    "\n",
+    "health_data = test_health_check()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. Root Endpoint\n",
+    "\n",
+    "Get API information and available endpoints."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "📋 API Information:\n",
+      "{\n",
+      "  \"message\": \"Multi-Agent Assistant API\",\n",
+      "  \"version\": \"1.0.0\",\n",
+      "  \"docs\": \"/docs\",\n",
+      "  \"health\": \"/health\"\n",
+      "}\n"
+     ]
+    }
+   ],
+   "source": [
+    "def test_root_endpoint():\n",
+    "    \"\"\"Test the root endpoint.\"\"\"\n",
+    "    try:\n",
+    "        response = requests.get(f\"{BASE_URL}/\")\n",
+    "        response.raise_for_status()\n",
+    "        data = response.json()\n",
+    "        \n",
+    "        print(\"📋 API Information:\")\n",
+    "        print(json.dumps(data, indent=2))\n",
+    "        \n",
+    "        return data\n",
+    "    except Exception as e:\n",
+    "        print(f\"❌ Error: {e}\")\n",
+    "        return None\n",
+    "\n",
+    "api_info = test_root_endpoint()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3. Streaming Chat with Server-Sent Events (SSE)\n",
+    "\n",
+    "Test the streaming chat endpoint that returns real-time updates."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "💬 Query: What is the current price of Bitcoin?\n",
+      "\n",
+      "📡 Streaming Response:\n",
+      "================================================================================\n",
+      "\n",
+      "💭 Step 1: Reasoning\n",
+      "   Thought: The user is asking for the current price of Bitcoin. The `CALL_CRYPTO` agent is designed to get cryptocurrency market data and prices. This is the most direct and appropriate tool to answer the query.\n",
+      "   Action: CRYPTO\n",
+      "   Justification: This action will directly retrieve the current price of Bitcoin, which is precisely what the user is asking for.\n",
+      "\n",
+      "🔧 Calling Crypto Agent...\n",
+      "\n",
+      "📊 Crypto Agent Results:\n",
+      "   The current price of Bitcoin is $95,748.\n",
+      "\n",
+      "💭 Step 2: Reasoning\n",
+      "   Thought: I have already called the `CALL_CRYPTO` agent, which provided the current price of Bitcoin as $95,748. This directly answers the user's query. I have sufficient information to provide a final answer.\n",
+      "   Action: FINISH\n",
+      "   Justification: The `CALL_CRYPTO` agent has successfully retrieved the current price of Bitcoin, which was the user's original query. No further information is needed.\n",
+      "\n",
+      "✨ Final Answer:\n",
+      "--------------------------------------------------------------------------------\n",
+      "The current price of Bitcoin is $95,748.\n",
+      "--------------------------------------------------------------------------------\n",
+      "\n",
+      "================================================================================\n"
+     ]
+    }
+   ],
+   "source": [
+    "def test_streaming_chat(message, history=None):\n",
+    "    \"\"\"Test streaming chat with SSE.\"\"\"\n",
+    "    if history is None:\n",
+    "        history = []\n",
+    "    \n",
+    "    payload = {\n",
+    "        \"message\": message,\n",
+    "        \"history\": history\n",
+    "    }\n",
+    "    \n",
+    "    print(f\"💬 Query: {message}\")\n",
+    "    print(\"\\n📡 Streaming Response:\")\n",
+    "    print(\"=\" * 80)\n",
+    "    \n",
+    "    try:\n",
+    "        response = requests.post(\n",
+    "            f\"{BASE_URL}/api/v1/chat/stream\",\n",
+    "            json=payload,\n",
+    "            headers={\"Accept\": \"text/event-stream\"},\n",
+    "            stream=True\n",
+    "        )\n",
+    "        response.raise_for_status()\n",
+    "        \n",
+    "        final_answer = \"\"\n",
+    "        \n",
+    "        for line in response.iter_lines():\n",
+    "            if line:\n",
+    "                line_str = line.decode('utf-8')\n",
+    "                if line_str.startswith('data: '):\n",
+    "                    data_str = line_str[6:]  # Remove 'data: ' prefix\n",
+    "                    try:\n",
+    "                        event = json.loads(data_str)\n",
+    "                        event_type = event.get('type', 'unknown')\n",
+    "                        \n",
+    "                        if event_type == 'thinking':\n",
+    "                            print(f\"\\n💭 Step {event.get('step', '?')}: Reasoning\")\n",
+    "                            print(f\"   Thought: {event.get('thought', 'N/A')}\")\n",
+    "                            print(f\"   Action: {event.get('action', 'N/A').upper()}\")\n",
+    "                            print(f\"   Justification: {event.get('justification', 'N/A')}\")\n",
+    "                        \n",
+    "                        elif event_type == 'action':\n",
+    "                            agent = event.get('agent', 'unknown')\n",
+    "                            print(f\"\\n🔧 Calling {agent.title()} Agent...\")\n",
+    "                        \n",
+    "                        elif event_type == 'observation':\n",
+    "                            agent = event.get('agent', 'unknown')\n",
+    "                            summary = event.get('summary', '')\n",
+    "                            print(f\"\\n📊 {agent.title()} Agent Results:\")\n",
+    "                            print(f\"   {summary[:200]}...\" if len(summary) > 200 else f\"   {summary}\")\n",
+    "                        \n",
+    "                        elif event_type == 'final_start':\n",
+    "                            print(\"\\n✨ Final Answer:\")\n",
+    "                            print(\"-\" * 80)\n",
+    "                        \n",
+    "                        elif event_type == 'final_token':\n",
+    "                            final_answer = event.get('accumulated', '')\n",
+    "                        \n",
+    "                        elif event_type == 'final_complete':\n",
+    "                            print(final_answer)\n",
+    "                            print(\"-\" * 80)\n",
+    "                        \n",
+    "                        elif event_type == 'error':\n",
+    "                            print(f\"\\n❌ Error: {event.get('error', 'Unknown error')}\")\n",
+    "                    \n",
+    "                    except json.JSONDecodeError:\n",
+    "                        continue\n",
+    "        \n",
+    "        print(\"\\n\" + \"=\" * 80)\n",
+    "        return final_answer\n",
+    "    \n",
+    "    except Exception as e:\n",
+    "        print(f\"\\n❌ Error: {e}\")\n",
+    "        return None\n",
+    "\n",
+    "# Test with a simple crypto query\n",
+    "result = test_streaming_chat(\"What is the current price of Bitcoin?\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Test with Different Queries"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "💬 Query: What are the top 5 cryptocurrencies by market cap?\n",
+      "\n",
+      "📡 Streaming Response:\n",
+      "================================================================================\n",
+      "\n",
+      "💭 Step 1: Reasoning\n",
+      "   Thought: The user is asking for a list of the top 5 cryptocurrencies based on their market capitalization. This is a specific query about cryptocurrency market data. I have an action called `CALL_CRYPTO` which is designed to get cryptocurrency market data, prices, and trends. This is the most direct and specialized tool for the job.\n",
+      "   Action: CRYPTO\n",
+      "   Justification: The `CALL_CRYPTO` action is the most appropriate tool to get real-time market capitalization data for cryptocurrencies, which is exactly what is needed to answer the user's query.\n",
+      "\n",
+      "🔧 Calling Crypto Agent...\n",
+      "\n",
+      "📊 Crypto Agent Results:\n",
+      "   The top 5 cryptocurrencies by market cap are:\n",
+      "\n",
+      "1. Bitcoin (BTC) - Market Cap: $2,025,171,098,463 - Price: $101,536\n",
+      "2. Ethereum (ETH) - Market Cap: $411,695,018,306 - Price: $3,410.68\n",
+      "3. Tether (USDT) ...\n",
+      "\n",
+      "💭 Step 2: Reasoning\n",
+      "   Thought: The CRYPTO agent has provided a list of the top 5 cryptocurrencies by market cap, which directly answers the user's query. I have all the necessary information to provide the final answer.\n",
+      "   Action: FINISH\n",
+      "   Justification: The information gathered from the CRYPTO agent is sufficient and complete to answer the user's question. No further actions are required.\n",
+      "\n",
+      "✨ Final Answer:\n",
+      "--------------------------------------------------------------------------------\n",
+      "Based on current market data, here are the top 5 cryptocurrencies ranked by market capitalization:\n",
+      "\n",
+      "**1. Bitcoin (BTC)**\n",
+      "*   **Market Cap:** $2,025,171,098,463\n",
+      "*   **Price:** $101,536.00\n",
+      "\n",
+      "**2. Ethereum (ETH)**\n",
+      "*   **Market Cap:** $411,695,018,306\n",
+      "*   **Price:** $3,410.68\n",
+      "\n",
+      "**3. Tether (USDT)**\n",
+      "*   **Market Cap:** $184,005,021,987\n",
+      "*   **Price:** $0.999813\n",
+      "\n",
+      "**4. XRP (XRP)**\n",
+      "*   **Market Cap:** $143,300,134,340*   **Price:** $2.38\n",
+      "\n",
+      "**5. BNB (BNB)**\n",
+      "*   **Market Cap:** $131,225,068,810\n",
+      "*   **Price:** $952.81\n",
+      "\n",
+      "**Key Insight:**\n",
+      "\n",
+      "Market capitalization is a key metric used to determine the relative size and value of a cryptocurrency. It is calculated by multiplying the current market price of a single coin by the total number of coins in circulation. As shown above, Bitcoin holds a dominant position with a market cap significantly larger than the others combined.\n",
+      "\n",
+      "*It is important to note that the cryptocurrency market is highly volatile, and these rankings, market caps, and prices are subject to change rapidly.*\n",
+      "--------------------------------------------------------------------------------\n",
+      "\n",
+      "================================================================================\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'Based on current market data, here are the top 5 cryptocurrencies ranked by market capitalization:\\n\\n**1. Bitcoin (BTC)**\\n*   **Market Cap:** $2,025,171,098,463\\n*   **Price:** $101,536.00\\n\\n**2. Ethereum (ETH)**\\n*   **Market Cap:** $411,695,018,306\\n*   **Price:** $3,410.68\\n\\n**3. Tether (USDT)**\\n*   **Market Cap:** $184,005,021,987\\n*   **Price:** $0.999813\\n\\n**4. XRP (XRP)**\\n*   **Market Cap:** $143,300,134,340*   **Price:** $2.38\\n\\n**5. BNB (BNB)**\\n*   **Market Cap:** $131,225,068,810\\n*   **Price:** $952.81\\n\\n**Key Insight:**\\n\\nMarket capitalization is a key metric used to determine the relative size and value of a cryptocurrency. It is calculated by multiplying the current market price of a single coin by the total number of coins in circulation. As shown above, Bitcoin holds a dominant position with a market cap significantly larger than the others combined.\\n\\n*It is important to note that the cryptocurrency market is highly volatile, and these rankings, market caps, and prices are subject to change rapidly.*'"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Test crypto query\n",
+    "test_streaming_chat(\"What are the top 5 cryptocurrencies by market cap?\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "💬 Query: What is the current stock price of Apple (AAPL)?\n",
+      "\n",
+      "📡 Streaming Response:\n",
+      "================================================================================\n",
+      "\n",
+      "💭 Step 1: Reasoning\n",
+      "   Thought: The user is asking for the current stock price of Apple (AAPL). The `CALL_STOCK` action is the most appropriate tool for this query as it is designed to get stock market data. I will use this action to retrieve the price for the ticker \"AAPL\".\n",
+      "   Action: STOCK\n",
+      "   Justification: This action is specifically designed to retrieve stock market data, which is exactly what is needed to answer the user's query about Apple's stock price.\n",
+      "\n",
+      "🔧 Calling Stock Agent...\n",
+      "\n",
+      "📊 Stock Agent Results:\n",
+      "   The current stock price of Apple (AAPL) is $273.47.\n",
+      "\n",
+      "💭 Step 2: Reasoning\n",
+      "   Thought: I have successfully retrieved the current stock price of Apple (AAPL) from the STOCK agent. This information directly answers the user's query. Therefore, I have sufficient information and can provide the final answer.\n",
+      "   Action: FINISH\n",
+      "   Justification: The STOCK agent has provided the exact information requested by the user. No further actions are necessary.\n",
+      "\n",
+      "✨ Final Answer:\n",
+      "--------------------------------------------------------------------------------\n",
+      "Based on the real-time data retrieved, the current stock price of Apple Inc. (AAPL) is **$273.47**.\n",
+      "\n",
+      "Please be aware that this price reflects the market value at the time the query was made and is subject to constant fluctuation based on market activity.\n",
+      "--------------------------------------------------------------------------------\n",
+      "\n",
+      "================================================================================\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'Based on the real-time data retrieved, the current stock price of Apple Inc. (AAPL) is **$273.47**.\\n\\nPlease be aware that this price reflects the market value at the time the query was made and is subject to constant fluctuation based on market activity.'"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Test stock query\n",
+    "test_streaming_chat(\"What is the current stock price of Apple (AAPL)?\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "💬 Query: Search for the latest AI developments in 2025\n",
+      "\n",
+      "📡 Streaming Response:\n",
+      "================================================================================\n",
+      "\n",
+      "💭 Step 1: Reasoning\n",
+      "   Thought: The user is asking about future AI developments in 2025. This is a general knowledge and predictive query. I have no information gathered yet. The best tool to find information about current events, news, and future trends is the web search tool. The other tools (CRYPTO, STOCK, FINANCE_TRACKER, RAG) are not relevant to this topic. Therefore, I should use CALL_SEARCH to find the requested information.\n",
+      "   Action: SEARCH\n",
+      "   Justification: This action is the most appropriate for finding information on future technological trends and developments like those anticipated for AI in 2025.\n",
+      "\n",
+      "🔧 Calling Search Agent...\n",
+      "\n",
+      "📊 Search Agent Results:\n",
+      "   I couldn't find any results for \"latest AI developments in 2025.\" Since 2025 is in the future, there are no \"developments\" yet. I can search for predictions or trends for AI in 2025 if you'd like.\n",
+      "\n",
+      "💭 Step 2: Reasoning\n",
+      "   Thought: The initial search for \"latest AI developments in 2025\" failed because 2025 is in the future. The SEARCH agent correctly pointed this out and suggested a better query: searching for \"predictions or trends for AI in 2025\". To answer the user's underlying question, I need to follow this suggestion and perform a new search with the revised query. This will gather the predictive information the user is likely looking for.\n",
+      "   Action: SEARCH\n",
+      "   Justification: The first search failed because the query was flawed. I will now use the refined query \"AI predictions and trends for 2025\" as suggested by the search agent to gather relevant information about what experts expect to see in the field of AI in the near future.\n",
+      "\n",
+      "🔧 Calling Search Agent...\n",
+      "\n",
+      "📊 Search Agent Results:\n",
+      "   I couldn't find any results for \"AI predictions and trends for 2025.\" This might be due to a temporary issue with the search engine or the way the query was phrased. I will try a more general search f...\n",
+      "\n",
+      "💭 Step 3: Reasoning\n",
+      "   Thought: I have attempted two searches so far, and both have failed to return results. The first search was too specific about \"developments\" in the future. The second, more reasonable search for \"predictions and trends for AI in 2025\" also failed, which the agent noted might be a temporary issue. The agent suggested a broader search for \"future of AI\". This is a logical next step to gather some relevant information, as it's a broader topic that is more likely to yield results which can then be analyzed for trends relevant to 2025. I still have no information to answer the user's query, so another search is necessary.\n",
+      "   Action: SEARCH\n",
+      "   Justification: My previous two search attempts failed. The search agent suggested a broader query, \"future of AI,\" which is a logical next step to gather relevant information to answer the user's question about AI in 2025. I need to execute this search to obtain the necessary information.\n",
+      "\n",
+      "🔧 Calling Search Agent...\n",
+      "\n",
+      "📊 Search Agent Results:\n",
+      "   I am sorry, but I was unable to find any search results for \"latest AI developments in 2025\" or related queries like \"AI predictions and trends for 2025\" and \"future of AI.\" It seems there might be an...\n",
+      "\n",
+      "💭 Step 4: Reasoning\n",
+      "   Thought: I have attempted to answer the user's query by using the `CALL_SEARCH` agent three times with progressively broader queries (\"latest AI developments in 2025\", \"AI predictions and trends for 2025\", and \"future of AI\"). Each attempt has failed, and the agent has explicitly stated that there might be an issue with the search tool itself. Since the only available tool capable of answering this query is not functioning, I cannot gather the necessary information. Further attempts to use the search tool are unlikely to succeed. Therefore, I must conclude the process and inform the user about the inability to retrieve the information due to a technical issue.\n",
+      "   Action: FINISH\n",
+      "   Justification: The `CALL_SEARCH` agent, which is the only relevant tool for this query, has failed multiple times and indicated a potential technical problem. I have exhausted all reasonable attempts to gather the information and cannot proceed further. The best course of action is to finish and communicate the issue to the user.\n",
+      "\n",
+      "✨ Final Answer:\n",
+      "--------------------------------------------------------------------------------\n",
+      "I was unable to find information on the latest AI developments for 2025.\n",
+      "\n",
+      "My attempt to answer your query involved a multi-step search process. Initially, I searched for \"latest AI developments in 2025,\" but since 2025 is in the future, no \"developments\" have occurred yet. I then broadened my search to look for \"AI predictions and trends for 2025\" and subsequently the \"future of AI.\"\n",
+      "\n",
+      "Unfortunately, all of these searches failed to return any results. This indicates a potential temporary issue with the search tool or that information specifically categorized for 2025 is not widely available at this moment.\n",
+      "\n",
+      "I recommend trying your query again later, as the issue with the search tool may be resolved.\n",
+      "--------------------------------------------------------------------------------\n",
+      "\n",
+      "================================================================================\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'I was unable to find information on the latest AI developments for 2025.\\n\\nMy attempt to answer your query involved a multi-step search process. Initially, I searched for \"latest AI developments in 2025,\" but since 2025 is in the future, no \"developments\" have occurred yet. I then broadened my search to look for \"AI predictions and trends for 2025\" and subsequently the \"future of AI.\"\\n\\nUnfortunately, all of these searches failed to return any results. This indicates a potential temporary issue with the search tool or that information specifically categorized for 2025 is not widely available at this moment.\\n\\nI recommend trying your query again later, as the issue with the search tool may be resolved.'"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Test web search query\n",
+    "test_streaming_chat(\"Search for the latest AI developments in 2025\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Test finance tracker - adding a transaction\n",
+    "test_streaming_chat(\"Add 10 shares of AAPL that I bought at $150\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "💬 Query: What's Bitcoin's price and what's the latest news about cryptocurrency?\n",
+      "\n",
+      "📡 Streaming Response:\n",
+      "================================================================================\n",
+      "\n",
+      "💭 Step 1: Reasoning\n",
+      "   Thought: The user is asking for two pieces of information: the current price of Bitcoin and the latest news about cryptocurrency. I need to address both parts of the query. The `CALL_CRYPTO` action is the most direct way to get the price of Bitcoin. I will start with that.\n",
+      "   Action: CRYPTO\n",
+      "   Justification: This action is specifically designed to retrieve cryptocurrency market data and prices, which directly answers the first part of the user's query about Bitcoin's price.\n",
+      "\n",
+      "🔧 Calling Crypto Agent...\n",
+      "\n",
+      "📊 Crypto Agent Results:\n",
+      "   I can only fetch the price of Bitcoin at the moment. Bitcoin's current price is $101,568. I cannot get the latest news about cryptocurrency.\n",
+      "\n",
+      "💭 Step 2: Reasoning\n",
+      "   Thought: I have successfully obtained the price of Bitcoin from the CRYPTO agent. However, the user's query also asks for the latest news about cryptocurrency, which the CRYPTO agent was unable to provide. To fulfill the second part of the request, I need to use an agent that can find current news. The SEARCH agent is the most suitable tool for this purpose.\n",
+      "   Action: SEARCH\n",
+      "   Justification: This action will allow me to find the latest news about cryptocurrency, which is the remaining piece of information needed to fully answer the user's query.\n",
+      "\n",
+      "🔧 Calling Search Agent...\n",
+      "\n",
+      "📊 Search Agent Results:\n",
+      "   Bitcoin's current price is $101,568.\n",
+      "\n",
+      "For the latest cryptocurrency news, you can check out these sources:\n",
+      "\n",
+      "*   **Crypto News:** https://cryptonews.com/\n",
+      "*   **Forbes Digital Assets:** https://www.forb...\n",
+      "\n",
+      "💭 Step 3: Reasoning\n",
+      "   Thought: I have successfully gathered the necessary information to answer the user's query. The CRYPTO and SEARCH agents both provided Bitcoin's current price, which is consistent. The SEARCH agent also provided a list of reliable sources for the latest cryptocurrency news. I do not need to call any more agents as I have a complete answer. I can now synthesize this information and provide the final response.\n",
+      "   Action: FINISH\n",
+      "   Justification: I have the price of Bitcoin and a list of sources for the latest cryptocurrency news. This is sufficient to fully answer the user's query.\n",
+      "\n",
+      "✨ Final Answer:\n",
+      "--------------------------------------------------------------------------------\n",
+      "The current price of Bitcoin is **$101,568**.\n",
+      "\n",
+      "For the latest news and in-depth coverage of the cryptocurrency market, you can refer to these reputable sources:\n",
+      "\n",
+      "*   **CoinDesk:** [https://www.coindesk.com/](https://www.coindesk.com/)\n",
+      "*   **Cointelegraph:** [https://cointelegraph.com/](https://cointelegraph.com/)\n",
+      "*   **Crypto News:** [https://cryptonews.com/](https://cryptonews.com/)\n",
+      "*   **Forbes Digital Assets:** [https://www.forbes.com/digital-assets/news/](https://www.forbes.com/digital-assets/news/)\n",
+      "*   **Reuters Cryptocurrency:** [https://www.reuters.com/markets/cryptocurrency/](https://www.reuters.com/markets/cryptocurrency/)\n",
+      "--------------------------------------------------------------------------------\n",
+      "\n",
+      "================================================================================\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'The current price of Bitcoin is **$101,568**.\\n\\nFor the latest news and in-depth coverage of the cryptocurrency market, you can refer to these reputable sources:\\n\\n*   **CoinDesk:** [https://www.coindesk.com/](https://www.coindesk.com/)\\n*   **Cointelegraph:** [https://cointelegraph.com/](https://cointelegraph.com/)\\n*   **Crypto News:** [https://cryptonews.com/](https://cryptonews.com/)\\n*   **Forbes Digital Assets:** [https://www.forbes.com/digital-assets/news/](https://www.forbes.com/digital-assets/news/)\\n*   **Reuters Cryptocurrency:** [https://www.reuters.com/markets/cryptocurrency/](https://www.reuters.com/markets/cryptocurrency/)'"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Test multi-agent query (requires multiple agents)\n",
+    "test_streaming_chat(\"What's Bitcoin's price and what's the latest news about cryptocurrency?\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4. WebSocket Chat\n",
+    "\n",
+    "Test the WebSocket endpoint for real-time bidirectional communication."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "💬 WebSocket Query: What is Ethereum's current price?\n",
+      "\n",
+      "📡 WebSocket Response:\n",
+      "================================================================================\n",
+      "\n",
+      "💭 Step 1: Reasoning\n",
+      "   Thought: The user is asking for the current price of Ethereum. Ethereum is a cryptocurrency. The `CALL_CRYPTO` action is specifically designed to get cryptocurrency market data and prices. Therefore, this is the most direct and appropriate action to take.\n",
+      "   Action: CRYPTO\n",
+      "\n",
+      "🔧 Calling Crypto Agent...\n",
+      "\n",
+      "📊 Crypto Agent Results\n",
+      "\n",
+      "💭 Step 2: Reasoning\n",
+      "   Thought: The user asked for the current price of Ethereum. The CRYPTO agent has already provided this information: \"The current price of Ethereum is $3423.75.\" I have a direct and complete answer to the user's query. Therefore, I can now finish.\n",
+      "   Action: FINISH\n",
+      "\n",
+      "✨ Final Answer:\n",
+      "--------------------------------------------------------------------------------\n",
+      "Based on the latest market data, the current price of Ethereum (ETH) is **$3,423.75**.\n",
+      "\n",
+      "It is important to note that cryptocurrency prices are highly volatile and can change rapidly. This price reflects a snapshot at the time the data was retrieved.\n",
+      "--------------------------------------------------------------------------------\n",
+      "\n",
+      "================================================================================\n"
+     ]
+    }
+   ],
+   "source": [
+    "async def test_websocket_chat(message, history=None):\n",
+    "    \"\"\"Test WebSocket chat endpoint.\"\"\"\n",
+    "    if history is None:\n",
+    "        history = []\n",
+    "    \n",
+    "    ws_url = BASE_URL.replace('http://', 'ws://') + '/ws/v1/chat'\n",
+    "    \n",
+    "    print(f\"💬 WebSocket Query: {message}\")\n",
+    "    print(\"\\n📡 WebSocket Response:\")\n",
+    "    print(\"=\" * 80)\n",
+    "    \n",
+    "    try:\n",
+    "        async with websockets.connect(ws_url) as websocket:\n",
+    "            # Send message\n",
+    "            await websocket.send(json.dumps({\n",
+    "                \"message\": message,\n",
+    "                \"history\": history\n",
+    "            }))\n",
+    "            \n",
+    "            final_answer = \"\"\n",
+    "            \n",
+    "            # Receive streaming updates\n",
+    "            while True:\n",
+    "                try:\n",
+    "                    response = await asyncio.wait_for(websocket.recv(), timeout=60.0)\n",
+    "                    event = json.loads(response)\n",
+    "                    event_type = event.get('type', 'unknown')\n",
+    "                    \n",
+    "                    if event_type == 'thinking':\n",
+    "                        print(f\"\\n💭 Step {event.get('step', '?')}: Reasoning\")\n",
+    "                        print(f\"   Thought: {event.get('thought', 'N/A')}\")\n",
+    "                        print(f\"   Action: {event.get('action', 'N/A').upper()}\")\n",
+    "                    \n",
+    "                    elif event_type == 'action':\n",
+    "                        agent = event.get('agent', 'unknown')\n",
+    "                        print(f\"\\n🔧 Calling {agent.title()} Agent...\")\n",
+    "                    \n",
+    "                    elif event_type == 'observation':\n",
+    "                        agent = event.get('agent', 'unknown')\n",
+    "                        summary = event.get('summary', '')\n",
+    "                        print(f\"\\n📊 {agent.title()} Agent Results\")\n",
+    "                    \n",
+    "                    elif event_type == 'final_start':\n",
+    "                        print(\"\\n✨ Final Answer:\")\n",
+    "                        print(\"-\" * 80)\n",
+    "                    \n",
+    "                    elif event_type == 'final_token':\n",
+    "                        final_answer = event.get('accumulated', '')\n",
+    "                    \n",
+    "                    elif event_type == 'final_complete':\n",
+    "                        print(final_answer)\n",
+    "                        print(\"-\" * 80)\n",
+    "                        break\n",
+    "                    \n",
+    "                    elif event_type == 'error':\n",
+    "                        print(f\"\\n❌ Error: {event.get('error', 'Unknown error')}\")\n",
+    "                        break\n",
+    "                \n",
+    "                except asyncio.TimeoutError:\n",
+    "                    print(\"\\n⏱️ Timeout waiting for response\")\n",
+    "                    break\n",
+    "            \n",
+    "            print(\"\\n\" + \"=\" * 80)\n",
+    "            return final_answer\n",
+    "    \n",
+    "    except Exception as e:\n",
+    "        print(f\"\\n❌ Error: {e}\")\n",
+    "        return None\n",
+    "\n",
+    "# Test WebSocket\n",
+    "ws_result = await test_websocket_chat(\"What is Ethereum's current price?\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 5. Document Upload\n",
+    "\n",
+    "Test uploading a document to the RAG agent."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def test_document_upload(file_path):\n",
+    "    \"\"\"Test document upload endpoint.\"\"\"\n",
+    "    try:\n",
+    "        if not Path(file_path).exists():\n",
+    "            print(f\"❌ File not found: {file_path}\")\n",
+    "            return None\n",
+    "        \n",
+    "        print(f\"📤 Uploading: {file_path}\")\n",
+    "        \n",
+    "        with open(file_path, 'rb') as f:\n",
+    "            files = {'file': (Path(file_path).name, f)}\n",
+    "            response = requests.post(\n",
+    "                f\"{BASE_URL}/api/v1/documents/upload\",\n",
+    "                files=files\n",
+    "            )\n",
+    "        \n",
+    "        response.raise_for_status()\n",
+    "        data = response.json()\n",
+    "        \n",
+    "        print(\"\\n✅ Upload Response:\")\n",
+    "        print(f\"  Success: {data['success']}\")\n",
+    "        print(f\"  Message: {data['message']}\")\n",
+    "        \n",
+    "        if data.get('details'):\n",
+    "            print(\"\\n  Details:\")\n",
+    "            for key, value in data['details'].items():\n",
+    "                print(f\"    {key}: {value}\")\n",
+    "        \n",
+    "        return data\n",
+    "    \n",
+    "    except requests.exceptions.HTTPError as e:\n",
+    "        print(f\"\\n❌ HTTP Error: {e}\")\n",
+    "        print(f\"   Response: {e.response.text}\")\n",
+    "        return None\n",
+    "    except Exception as e:\n",
+    "        print(f\"\\n❌ Error: {e}\")\n",
+    "        return None\n",
+    "\n",
+    "# Example: Upload a test file (update path to your actual file)\n",
+    "test_document_upload(\"PATH_TO_YOUR_DOCUEMNT\")\n",
+    "\n",
+    "print(\"⚠️ To test document upload, uncomment the line above and provide a valid file path\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "✅ Created test file: test_document.txt\n",
+      "📤 Uploading: test_document.txt\n",
+      "\n",
+      "✅ Upload Response:\n",
+      "  Success: True\n",
+      "  Message: Document uploaded successfully\n",
+      "\n",
+      "  Details:\n",
+      "    filename: tmphdduvt25.txt\n",
+      "    file_type: .txt\n",
+      "    chunks_added: 1\n",
+      "    total_documents: 229\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Create a test text file and upload it\n",
+    "test_file_path = \"test_document.txt\"\n",
+    "\n",
+    "with open(test_file_path, 'w') as f:\n",
+    "    f.write(\"\"\"\n",
+    "    Test Document for RAG Agent\n",
+    "    \n",
+    "    This is a sample document for testing the RAG agent's document upload functionality.\n",
+    "    \n",
+    "    Key Information:\n",
+    "    - The multi-agent system uses Google Gemini 2.5 Pro\n",
+    "    - It implements a ReAct (Reasoning + Acting) pattern\n",
+    "    - Available agents: Crypto, Stock, RAG, Search, Finance Tracker\n",
+    "    - Each agent uses specialized MCP servers for their domain\n",
+    "    \n",
+    "    The system can handle co plex queries that require multiple agents working together.\n",
+    "    \"\"\")\n",
+    "\n",
+    "print(f\"✅ Created test file: {test_file_path}\")\n",
+    "\n",
+    "# Upload the test file\n",
+    "upload_result = test_document_upload(test_file_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "💬 Query: What applications of AI agents are described in my collection?\n",
+      "\n",
+      "📡 Streaming Response:\n",
+      "================================================================================\n",
+      "\n",
+      "💭 Step 1: Reasoning\n",
+      "   Thought: The user is asking about applications of AI agents described in \"my collection\". This indicates that the information should be retrieved from the user's uploaded documents. The `CALL_RAG` tool is designed for this purpose.\n",
+      "   Action: RAG\n",
+      "   Justification: The query specifically asks for information from \"my collection,\" which implies searching the user's uploaded documents. `CALL_RAG` is the appropriate tool to retrieve information from these documents.\n",
+      "\n",
+      "🔧 Calling Rag Agent...\n",
+      "\n",
+      "📊 Rag Agent Results:\n",
+      "   Based on the provided document excerpts, there is no information available regarding the current status of any project. The documents discuss applications of AI agents, challenges in their integration...\n",
+      "\n",
+      "💭 Step 2: Reasoning\n",
+      "   Thought: The user asked for \"What applications of AI agents are described in my collection?\". I previously called `CALL_RAG`, and the observation stated: \"The documents discuss applications of AI agents, challenges in their integration, and various machine learning models and their use cases.\" This confirms that the information about AI agent applications *is* present in the documents. However, the previous `RAG` call did not actually list these applications. I need to call `CALL_RAG` again, but this time with a more specific prompt to extract and list the applications of AI agents mentioned in the documents.\n",
+      "   Action: RAG\n",
+      "   Justification: The previous `CALL_RAG` observation confirmed that the documents contain information about \"applications of AI agents\". I need to call `CALL_RAG` again to specifically extract and list these applications, as the previous call did not provide them.\n",
+      "\n",
+      "🔧 Calling Rag Agent...\n",
+      "\n",
+      "📊 Rag Agent Results:\n",
+      "   Based on the provided document excerpts, there is no information available regarding the benefits of the Mediterranean diet for brain health. The documents discuss applications of AI agents, challenge...\n",
+      "\n",
+      "💭 Step 3: Reasoning\n",
+      "   Thought: The user is asking for a list of AI agent applications from their collection. I have called `CALL_RAG` twice. The first call indicated that the documents discuss \"applications of AI agents\". The second call was problematic, mentioning \"Mediterranean diet\" while still stating that \"The documents discuss applications of AI agents\". This indicates that the RAG tool is acknowledging the presence of the information but failing to extract and list the specific applications. I need to call `CALL_RAG` again, but this time, I must ensure the prompt is very explicit about *listing* the applications to overcome the previous failures.\n",
+      "   Action: RAG\n",
+      "   Justification: The `CALL_RAG` tool is the only way to access information from the user's uploaded documents (\"my collection\"). Despite previous attempts, the tool has not yet provided the actual list of AI agent applications, even though it confirms the information is present. I need to try again with a more precise prompt to extract and list these applications.\n",
+      "\n",
+      "🔧 Calling Rag Agent...\n",
+      "\n",
+      "📊 Rag Agent Results:\n",
+      "   Based on the provided document excerpts, the following applications of AI agents are described:\n",
+      "\n",
+      "For **Marketing Professionals**:\n",
+      "*   Content generation agents\n",
+      "*   Market research agents\n",
+      "*   Performan...\n",
+      "\n",
+      "💭 Step 4: Reasoning\n",
+      "   Thought: I have successfully retrieved the applications of AI agents described in the user's collection using `CALL_RAG`. The information gathered directly answers the user's query.\n",
+      "   Action: FINISH\n",
+      "   Justification: I have sufficient information to answer the user's query about the applications of AI agents described in their collection.\n",
+      "\n",
+      "✨ Final Answer:\n",
+      "--------------------------------------------------------------------------------\n",
+      "Based on the documents in your collection, AI agents are described with specific applications for both marketing and sales professionals:\n",
+      "\n",
+      "**For Marketing Professionals:**\n",
+      "*   **Content generation agents:** To assist in creating various forms of marketing content.\n",
+      "*   **Market research agents:** For conducting research to understand market trends and opportunities.\n",
+      "*   **Performance analytics agents:** To analyze the effectiveness of marketing campaigns and strategies.\n",
+      "*   **Audience insight agents:** For gathering and interpreting data about target audiences.\n",
+      "\n",
+      "**For Sales Professionals:**\n",
+      "*   **Prospect research agents:** To identify and gather information on potential clients.\n",
+      "*   **Outreach customization agents:** For tailoring communication to individual prospects.\n",
+      "*   **Meeting preparation agents:** To assist in preparing for sales meetings.\n",
+      "*   **Follow-up management agents:** For organizing and executing post-meeting follow-up tasks.\n",
+      "--------------------------------------------------------------------------------\n",
+      "\n",
+      "================================================================================\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Now query the uploaded document\n",
+    "if upload_result and upload_result.get('success'):\n",
+    "    test_streaming_chat(\"What applications of AI agents are described in my collection?\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 6. Conversation History\n",
+    "\n",
+    "Test chat with conversation history."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "====================================================================================================\n",
+      "MESSAGE 1\n",
+      "====================================================================================================\n",
+      "💬 Query: What is Bitcoin?\n",
+      "\n",
+      "📡 Streaming Response:\n",
+      "================================================================================\n",
+      "\n",
+      "💭 Step 1: Reasoning\n",
+      "   Thought: The user is asking for a definition of \"Bitcoin\". This is a general knowledge question. I do not have any information yet. The best tool for answering general knowledge questions is `CALL_SEARCH`. The other tools are more specialized: `CALL_CRYPTO` is for market data, not definitions; `CALL_STOCK` and `CALL_FINANCE_TRACKER` are for traditional finance; and `CALL_RAG` requires pre-existing documents. Therefore, I should use `CALL_SEARCH` to find out what Bitcoin is.\n",
+      "   Action: SEARCH\n",
+      "   Justification: The user's query \"What is Bitcoin?\" is a general knowledge question. The `CALL_SEARCH` action is the most appropriate tool to find a definition and explanation from the web.\n",
+      "\n",
+      "🔧 Calling Search Agent...\n",
+      "\n",
+      "📊 Search Agent Results:\n",
+      "   Bitcoin is a decentralized digital currency that allows for direct transactions between users without the need for an intermediary like a bank. It was invented in 2008 by an unknown entity or group us...\n",
+      "\n",
+      "💭 Step 2: Reasoning\n",
+      "   Thought: I have successfully used the `CALL_SEARCH` agent to get a clear and comprehensive definition of Bitcoin. The information gathered explains what it is, who created it, and the technology behind it. This is sufficient to answer the user's query. I do not need to call any other agents. I can now provide the final answer.\n",
+      "   Action: FINISH\n",
+      "   Justification: I have a complete answer to the user's question \"What is Bitcoin?\" from the previous `CALL_SEARCH` action. No further information is required.\n",
+      "\n",
+      "✨ Final Answer:\n",
+      "--------------------------------------------------------------------------------\n",
+      "Based on the information gathered, here is a comprehensive answer to your query.\n",
+      "\n",
+      "### What is Bitcoin?\n",
+      "\n",
+      "Bitcoin is a decentralized digital currency that enables direct, peer-to-peer transactions between users without the need for an intermediary like a bank or financial institution. It was the first cryptocurrency to be created and remains the most well-known.\n",
+      "\n",
+      "#### Key Features:*   **Decentralized:** Unlike traditional currencies issued by governments (like the U.S. Dollar), Bitcoin is not controlled by any single entity. This means it is resistant to censorship and manipulation by a central authority.\n",
+      "*   **Digital Nature:** Bitcoin exists only in the digital realm. It is not a physical coin or bill but a balance associated with a digital address.\n",
+      "*   **Peer-to-Peer Technology:** Transactions are sent directly from one user to another across a global network of computers.\n",
+      "*   **Blockchain Technology:** All transactions are recorded on a public, distributed ledger called the blockchain. This technology ensures transparency and security, as every transaction is permanent and visible to everyone on the network.\n",
+      "*   **Cryptography:** Advanced cryptographic techniques are used to secure the network, verify transactions, and control the creation of new bitcoins.\n",
+      "\n",
+      "#### Origins:\n",
+      "\n",
+      "Bitcoin was invented in 2008 by an unknown person or group of people using the pseudonym **Satoshi Nakamoto**. The network went live in 2009, marking the beginning of its use as a currency.\n",
+      "\n",
+      "***\n",
+      "*Sources: Forbes Advisor, Investopedia, Bitcoin.org, Analytics Insight, Wikipedia, Britannica Money, Crypto.com, Cointelegraph*\n",
+      "--------------------------------------------------------------------------------\n",
+      "\n",
+      "================================================================================\n",
+      "\n",
+      "====================================================================================================\n",
+      "MESSAGE 2 (with context from previous message)\n",
+      "====================================================================================================\n",
+      "💬 Query: What is its current price?\n",
+      "\n",
+      "📡 Streaming Response:\n",
+      "================================================================================\n",
+      "\n",
+      "💭 Step 1: Reasoning\n",
+      "   Thought: The user is asking for the current price of \"it\". Based on the previous turn in the conversation history, \"it\" refers to Bitcoin. To answer this question, I need to get the current market price of Bitcoin. The `CALL_CRYPTO` tool is specifically designed to retrieve cryptocurrency prices.\n",
+      "   Action: CRYPTO\n",
+      "   Justification: This action will provide the real-time price of Bitcoin, which is the specific information needed to answer the user's query.\n",
+      "\n",
+      "🔧 Calling Crypto Agent...\n",
+      "\n",
+      "📊 Crypto Agent Results:\n",
+      "   The current price of Bitcoin is $98,857. Over the last 24 hours, its price has changed by -2.74%, and its 24-hour trading volume is $98,820,417,484.34. The market cap for Bitcoin is $1,970,383,895,456...\n",
+      "\n",
+      "💭 Step 2: Reasoning\n",
+      "   Thought: I have successfully retrieved the current price of Bitcoin using the `CALL_CRYPTO` agent. The information gathered directly answers the user's query. Therefore, I have sufficient information and should now provide the final answer.\n",
+      "   Action: FINISH\n",
+      "   Justification: The `CALL_CRYPTO` agent provided the current price of Bitcoin, which is exactly what the user asked for. No further information is needed.\n",
+      "\n",
+      "✨ Final Answer:\n",
+      "--------------------------------------------------------------------------------\n",
+      "Based on real-time market data, the current price of Bitcoin is **$98,857**.\n",
+      "\n",
+      "Here is some additional market information:\n",
+      "\n",
+      "*   **24-Hour Price Change:** -2.74%\n",
+      "*   **Market Cap:** $1,970,383,895,456.65*   **24-Hour Trading Volume:** $98,820,417,484.34\n",
+      "\n",
+      "***\n",
+      "*Please note: Cryptocurrency prices are highly volatile and can change rapidly. This information reflects the market at the time this query was made.*\n",
+      "--------------------------------------------------------------------------------\n",
+      "\n",
+      "================================================================================\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Start a conversation\n",
+    "history = []\n",
+    "\n",
+    "# First message\n",
+    "print(\"\\n\" + \"=\"*100)\n",
+    "print(\"MESSAGE 1\")\n",
+    "print(\"=\"*100)\n",
+    "result1 = test_streaming_chat(\"What is Bitcoin?\", history=history)\n",
+    "history.append({\"role\": \"user\", \"content\": \"What is Bitcoin?\"})\n",
+    "history.append({\"role\": \"assistant\", \"content\": result1})\n",
+    "\n",
+    "time.sleep(2)\n",
+    "\n",
+    "# Follow-up question (with context)\n",
+    "print(\"\\n\" + \"=\"*100)\n",
+    "print(\"MESSAGE 2 (with context from previous message)\")\n",
+    "print(\"=\"*100)\n",
+    "result2 = test_streaming_chat(\"What is its current price?\", history=history)\n",
+    "history.append({\"role\": \"user\", \"content\": \"What is its current price?\"})\n",
+    "history.append({\"role\": \"assistant\", \"content\": result2})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 7. Performance Testing\n",
+    "\n",
+    "Test response times and measure performance."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "⏱️ Performance Metrics for: 'What is Bitcoin price?'\n",
+      "   Time to first token: 14.65s\n",
+      "   Total response time: 36.27s\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'first_token': 14.646224975585938, 'total': 36.274803161621094}"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import time\n",
+    "\n",
+    "def measure_response_time(query):\n",
+    "    \"\"\"Measure response time for a query.\"\"\"\n",
+    "    payload = {\"message\": query, \"history\": []}\n",
+    "    \n",
+    "    start_time = time.time()\n",
+    "    first_token_time = None\n",
+    "    \n",
+    "    try:\n",
+    "        response = requests.post(\n",
+    "            f\"{BASE_URL}/api/v1/chat/stream\",\n",
+    "            json=payload,\n",
+    "            headers={\"Accept\": \"text/event-stream\"},\n",
+    "            stream=True\n",
+    "        )\n",
+    "        \n",
+    "        for i, line in enumerate(response.iter_lines()):\n",
+    "            if i == 0 and first_token_time is None:\n",
+    "                first_token_time = time.time() - start_time\n",
+    "            if line and b'final_complete' in line:\n",
+    "                break\n",
+    "        \n",
+    "        total_time = time.time() - start_time\n",
+    "        \n",
+    "        print(f\"\\n⏱️ Performance Metrics for: '{query}'\")\n",
+    "        print(f\"   Time to first token: {first_token_time:.2f}s\")\n",
+    "        print(f\"   Total response time: {total_time:.2f}s\")\n",
+    "        \n",
+    "        return {\"first_token\": first_token_time, \"total\": total_time}\n",
+    "    \n",
+    "    except Exception as e:\n",
+    "        print(f\"❌ Error: {e}\")\n",
+    "        return None\n",
+    "\n",
+    "# Test with simple query\n",
+    "measure_response_time(\"What is Bitcoin price?\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 8. Error Handling Tests\n",
+    "\n",
+    "Test how the API handles various error conditions."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Test empty message\n",
+    "print(\"Testing empty message:\")\n",
+    "test_streaming_chat(\"\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Test invalid file upload\n",
+    "print(\"Testing invalid file type:\")\n",
+    "\n",
+    "invalid_file_path = \"/tmp/test.exe\"\n",
+    "with open(invalid_file_path, 'w') as f:\n",
+    "    f.write(\"invalid content\")\n",
+    "\n",
+    "test_document_upload(invalid_file_path)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 9. API Documentation\n",
+    "\n",
+    "The FastAPI server provides automatic interactive documentation.\n",
+    "\n",
+    "**Access the documentation at:**\n",
+    "- Swagger UI: http://localhost:8000/docs\n",
+    "- ReDoc: http://localhost:8000/redoc\n",
+    "\n",
+    "You can test all endpoints directly from the browser using the Swagger UI!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "📚 FastAPI Interactive Documentation\n",
+      "\n",
+      "🔗 Swagger UI: http://localhost:8000/docs\n",
+      "🔗 ReDoc: http://localhost:8000/redoc\n"
+     ]
+    }
+   ],
+   "source": [
+    "from IPython.display import IFrame\n",
+    "\n",
+    "# Display Swagger UI in notebook (if server is running)\n",
+    "print(\"📚 FastAPI Interactive Documentation\")\n",
+    "print(f\"\\n🔗 Swagger UI: {BASE_URL}/docs\")\n",
+    "print(f\"🔗 ReDoc: {BASE_URL}/redoc\")\n",
+    "\n",
+    "# Uncomment to embed in notebook\n",
+    "# IFrame(f\"{BASE_URL}/docs\", width=1000, height=600)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "venv (3.11.5)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

scripts/setup.sh

@@ -0,0 +1,85 @@
+#!/bin/bash
+
+echo "======================================"
+echo "Multi-Agent Crypto Assistant Setup"
+echo "======================================"
+echo ""
+
+# Check Python version
+python_version=$(python3 --version 2>&1 | grep -oP '\d+\.\d+')
+required_version="3.9"
+
+if [ "$(printf '%s\n' "$required_version" "$python_version" | sort -V | head -n1)" != "$required_version" ]; then 
+    echo "❌ Error: Python 3.9 or higher is required"
+    echo "Current version: $(python3 --version)"
+    exit 1
+fi
+
+echo "✅ Python version check passed: $(python3 --version)"
+echo ""
+
+# Create virtual environment
+echo "📦 Creating virtual environment..."
+python3 -m venv venv
+
+if [ $? -ne 0 ]; then
+    echo "❌ Failed to create virtual environment"
+    exit 1
+fi
+
+echo "✅ Virtual environment created"
+echo ""
+
+# Activate virtual environment
+echo "🔌 Activating virtual environment..."
+source venv/bin/activate
+
+if [ $? -ne 0 ]; then
+    echo "❌ Failed to activate virtual environment"
+    exit 1
+fi
+
+echo "✅ Virtual environment activated"
+echo ""
+
+# Install dependencies
+echo "📥 Installing dependencies..."
+pip install --upgrade pip
+pip install -r requirements.txt
+
+if [ $? -ne 0 ]; then
+    echo "❌ Failed to install dependencies"
+    exit 1
+fi
+
+echo "✅ Dependencies installed"
+echo ""
+
+# Setup .env file
+if [ ! -f .env ]; then
+    echo "📝 Setting up .env file..."
+    cp .env.example .env
+    echo "✅ .env file created from template"
+    echo ""
+    echo "⚠️  IMPORTANT: Edit .env and add your API keys:"
+    echo "   - GEMINI_API_KEY"
+    echo "   - COINGECKO_API_KEY"
+    echo ""
+else
+    echo "✅ .env file already exists"
+    echo ""
+fi
+
+echo "======================================"
+echo "✨ Setup Complete!"
+echo "======================================"
+echo ""
+echo "Next steps:"
+echo "1. Edit .env file and add your API keys"
+echo "2. Activate the virtual environment:"
+echo "   source venv/bin/activate"
+echo "3. Run the application:"
+echo "   python app.py"
+echo ""
+echo "The app will be available at: http://localhost:7860"
+echo ""

scripts/start.sh

@@ -0,0 +1,58 @@
+#!/bin/bash
+# Startup script to run both FastAPI backend and Streamlit frontend
+
+set -e
+
+echo "🚀 Starting Multi-Agent Assistant..."
+
+# Function to handle shutdown
+shutdown() {
+    echo "🛑 Shutting down services..."
+    kill $FASTAPI_PID $STREAMLIT_PID 2>/dev/null || true
+    wait
+    exit 0
+}
+
+trap shutdown SIGTERM SIGINT
+
+# Start FastAPI backend in background
+echo "📡 Starting FastAPI backend on port 8000..."
+uvicorn src.api.main:app --host 0.0.0.0 --port 8000 &
+FASTAPI_PID=$!
+
+# Wait for FastAPI to be ready
+echo "⏳ Waiting for FastAPI to be ready..."
+for i in {1..30}; do
+    if curl -s http://localhost:8000/health > /dev/null 2>&1; then
+        echo "✅ FastAPI is ready!"
+        break
+    fi
+    if [ $i -eq 30 ]; then
+        echo "❌ FastAPI failed to start"
+        kill $FASTAPI_PID 2>/dev/null || true
+        exit 1
+    fi
+    sleep 2
+done
+
+# Start Streamlit frontend in foreground
+echo "🎨 Starting Streamlit UI on port 8501..."
+streamlit run ui/streamlit_app.py \
+    --server.port 8501 \
+    --server.address 0.0.0.0 \
+    --server.headless true \
+    --browser.gatherUsageStats false \
+    --server.enableCORS false \
+    --server.enableXsrfProtection true &
+
+STREAMLIT_PID=$!
+
+echo "✅ All services started!"
+echo "📡 FastAPI: http://localhost:8000"
+echo "🎨 Streamlit: http://localhost:8501"
+
+# Wait for either process to exit
+wait -n
+
+# If we get here, one process exited - shut down everything
+shutdown

src/agents/crypto_agent_mcp.py

@@ -0,0 +1,180 @@
+"""Crypto Agent using CoinGecko MCP Server via LangChain MCP adapters."""
+import json
+import shutil
+from typing import Any, Dict, List, Optional
+
+from src.core.config import config
+from langchain_core.messages import AIMessage, HumanMessage, ToolMessage
+from langchain_core.tools import BaseTool
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_mcp_adapters.client import MultiServerMCPClient
+
+
+def _resolve_executable(candidates: List[str]) -> str:
+    """Return first executable path found in PATH."""
+    for name in candidates:
+        resolved = shutil.which(name)
+        if resolved:
+            return resolved
+    raise FileNotFoundError(f"Unable to locate any of: {', '.join(candidates)}")
+
+
+def _to_text(payload: Any) -> str:
+    """Convert model or tool output into a printable string."""
+    if isinstance(payload, str):
+        return payload
+    try:
+        return json.dumps(payload, ensure_ascii=False)
+    except TypeError:
+        return str(payload)
+
+
+class CryptoAgentMCP:
+    """Agent specialized in cryptocurrency data using CoinGecko MCP Server."""
+
+    def __init__(self, use_public_endpoint: bool = False):
+        self.name = "Crypto Agent (MCP)"
+        self.description = "Cryptocurrency market data and analysis expert using CoinGecko MCP Server"
+        self.use_public_endpoint = use_public_endpoint
+        self.mcp_client: Optional[MultiServerMCPClient] = None
+        self.model: Optional[ChatGoogleGenerativeAI] = None
+        self.model_with_tools = None
+        self.tools: List[BaseTool] = []
+        self.tool_map: Dict[str, BaseTool] = {}
+
+    async def initialize(self) -> None:
+        """Initialize the agent with CoinGecko MCP Server."""
+        print(f"🔧 Initializing {self.name}...")
+
+        try:
+            # Connect to CoinGecko MCP Server
+            print(f"  📡 Connecting to CoinGecko MCP Server...")
+
+            connection_name = "coingecko"
+            connections: Dict[str, Dict[str, Any]] = {}
+
+            api_key = (config.COINGECKO_API_KEY or "").strip()
+            if api_key.lower().startswith("demo"):
+                print("    Demo API key detected. Using public endpoint with limited access...")
+                self.use_public_endpoint = True
+
+            if self.use_public_endpoint or not api_key:
+                print("    Using public SSE endpoint...")
+                connections[connection_name] = {
+                    "transport": "sse",
+                    "url": "https://mcp.api.coingecko.com/sse",
+                }
+            else:
+                print("    Using Pro endpoint with API key...")
+                npx_executable = _resolve_executable(["npx.cmd", "npx.exe", "npx"])
+                env = {
+                    "COINGECKO_PRO_API_KEY": api_key,
+                    "COINGECKO_ENVIRONMENT": "pro",
+                }
+                connections[connection_name] = {
+                    "transport": "stdio",
+                    "command": npx_executable,
+                    "args": ["-y", "@coingecko/coingecko-mcp"],
+                    "env": env,
+                }
+
+            self.mcp_client = MultiServerMCPClient(connections)
+
+            # Load MCP tools as LangChain tools
+            self.tools = await self.mcp_client.get_tools(server_name=connection_name)
+            if not self.tools:
+                raise RuntimeError("No tools available from CoinGecko MCP Server")
+
+            self.tool_map = {tool.name: tool for tool in self.tools}
+
+            # Initialize Gemini chat model bound to tools
+            self.model = ChatGoogleGenerativeAI(
+                model="gemini-2.5-flash",
+                temperature=0.1,
+                google_api_key=config.GOOGLE_API_KEY,
+            )
+            self.model_with_tools = self.model.bind_tools(self.tools)
+
+            print(f"  ✅ Connected to CoinGecko MCP Server with {len(self.tools)} tools")
+
+            print(f"  ✅ {self.name} ready!")
+
+        except Exception as e:
+            import traceback
+            print(f"  ❌ Error initializing {self.name}: {e}")
+            print(f"  📋 Full error details:")
+            traceback.print_exc()
+            raise
+
+    async def process(self, query: str, history: Optional[List[Dict[str, str]]] = None) -> Dict[str, Any]:
+        """Process a query using CoinGecko MCP Server tools."""
+        try:
+            print(f"\n💰 {self.name} processing: '{query}'")
+            messages: List[Any] = []
+            if history:
+                trimmed_history = history[-10:]
+                for turn in trimmed_history:
+                    user_text = turn.get("user")
+                    if user_text:
+                        messages.append(HumanMessage(content=user_text))
+                    assistant_text = turn.get("assistant")
+                    if assistant_text:
+                        messages.append(AIMessage(content=assistant_text))
+            messages.append(HumanMessage(content=query))
+            final_response = ""
+            tool_calls_info = []
+
+            while True:
+                if not self.model_with_tools:
+                    raise RuntimeError("Model not initialized with tools")
+
+                ai_message = await self.model_with_tools.ainvoke(messages)
+                messages.append(ai_message)
+
+                tool_calls = getattr(ai_message, "tool_calls", [])
+                if not tool_calls:
+                    final_response = _to_text(ai_message.content)
+                    break
+
+                for call in tool_calls:
+                    tool_name = call.get("name")
+                    tool_args = call.get("args", {})
+                    tool_call_id = call.get("id")
+                    print(f"  🔧 MCP Tool call: {tool_name}({tool_args})")
+                    tool_calls_info.append(f"🔧 MCP Tool call: {tool_name}({tool_args})")
+
+                    tool = self.tool_map.get(tool_name)
+                    if not tool:
+                        tool_result = {"error": f"Tool '{tool_name}' not found"}
+                    else:
+                        tool_result = await tool.ainvoke(tool_args)
+
+                    messages.append(
+                        ToolMessage(
+                            content=_to_text(tool_result),
+                            tool_call_id=tool_call_id or "",
+                        )
+                    )
+
+            return {
+                "success": True,
+                "agent": self.name,
+                "response": final_response,
+                "query": query,
+                "tool_calls": tool_calls_info
+            }
+
+        except Exception as e:
+            print(f"  ❌ Error in {self.name}: {e}")
+            import traceback
+            traceback.print_exc()
+            return {
+                "success": False,
+                "agent": self.name,
+                "error": str(e),
+                "query": query
+            }
+
+    async def cleanup(self) -> None:
+        """Cleanup resources."""
+        print(f"🧹 {self.name} cleaned up")

src/agents/finance_tracker_agent_mcp.py

@@ -0,0 +1,351 @@
+"""Finance Tracker Agent using MCP Toolbox Docker server via HTTP."""
+import json
+from typing import Any, Dict, List, Optional, Literal
+from pydantic import BaseModel, Field
+
+from src.core.config import config
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_core.messages import AIMessage, HumanMessage, ToolMessage
+from toolbox_langchain import ToolboxClient
+
+
+def _to_text(payload: Any) -> str:
+    """Convert model or tool output into a printable string."""
+    if isinstance(payload, str):
+        return payload
+    try:
+        return json.dumps(payload, ensure_ascii=False)
+    except TypeError:
+        return str(payload)
+
+
+# Pydantic schemas for structured output
+class PortfolioHolding(BaseModel):
+    """A single stock holding in the portfolio."""
+    symbol: str = Field(description="Stock ticker symbol (e.g., AAPL, MSFT)")
+    quantity: float = Field(description="Number of shares held")
+    avg_cost_basis: float = Field(description="Average cost per share")
+    total_invested: float = Field(description="Total amount invested (quantity * avg_cost_basis)")
+    realized_gains: Optional[float] = Field(default=None, description="Realized gains/losses from sales")
+
+
+class TransactionRecord(BaseModel):
+    """A stock transaction record."""
+    symbol: str = Field(description="Stock ticker symbol")
+    transaction_type: Literal["BUY", "SELL"] = Field(description="Type of transaction")
+    quantity: float = Field(description="Number of shares")
+    price: float = Field(description="Price per share")
+    transaction_date: str = Field(description="Date of transaction")
+    notes: Optional[str] = Field(default=None, description="Additional notes")
+
+
+class PortfolioResponse(BaseModel):
+    """Structured response for portfolio queries."""
+    response_type: Literal["portfolio_view", "transaction_added", "transaction_history", "general_response"] = Field(
+        description="Type of response being provided"
+    )
+    summary: str = Field(description="Brief summary of the response")
+    holdings: Optional[List[PortfolioHolding]] = Field(
+        default=None,
+        description="Current portfolio holdings (for portfolio_view)"
+    )
+    transaction: Optional[TransactionRecord] = Field(
+        default=None,
+        description="Transaction details (for transaction_added)"
+    )
+    transactions: Optional[List[TransactionRecord]] = Field(
+        default=None,
+        description="List of transactions (for transaction_history)"
+    )
+    total_portfolio_value: Optional[float] = Field(
+        default=None,
+        description="Total portfolio value"
+    )
+    insights: Optional[List[str]] = Field(
+        default=None,
+        description="Key insights or recommendations"
+    )
+
+
+def format_portfolio_response(response: PortfolioResponse) -> str:
+    """Format structured portfolio response into readable text."""
+    output = []
+
+    # Add summary
+    output.append(response.summary)
+    output.append("")
+
+    # Format holdings if present
+    if response.holdings:
+        output.append("## Current Portfolio Holdings")
+        output.append("")
+        # Create table header
+        output.append("| Symbol | Shares | Avg Cost | Total Invested | Realized Gains |")
+        output.append("|--------|--------|----------|----------------|----------------|")
+        # Add each holding as a table row
+        for holding in response.holdings:
+            realized_gains = f"${holding.realized_gains:.2f}" if holding.realized_gains is not None else "$0.00"
+            output.append(
+                f"| {holding.symbol} | {holding.quantity} | "
+                f"${holding.avg_cost_basis:.2f} | ${holding.total_invested:.2f} | {realized_gains} |"
+            )
+        output.append("")
+
+    # Format single transaction if present
+    if response.transaction:
+        output.append("## Transaction Details")
+        output.append("")
+        t = response.transaction
+        output.append(f"- **Type**: {t.transaction_type}")
+        output.append(f"- **Symbol**: {t.symbol}")
+        output.append(f"- **Quantity**: {t.quantity} shares")
+        output.append(f"- **Price**: ${t.price:.2f} per share")
+        output.append(f"- **Date**: {t.transaction_date}")
+        output.append(f"- **Total Amount**: ${t.quantity * t.price:.2f}")
+        if t.notes:
+            output.append(f"- **Notes**: {t.notes}")
+        output.append("")
+
+    # Format transaction history if present
+    if response.transactions:
+        output.append("## Transaction History")
+        output.append("")
+        for t in response.transactions:
+            output.append(f"**{t.transaction_date}** - {t.transaction_type} {t.quantity} shares of {t.symbol} @ ${t.price:.2f}")
+            if t.notes:
+                output.append(f"  Notes: {t.notes}")
+        output.append("")
+
+    # Add total portfolio value if present
+    if response.total_portfolio_value is not None:
+        output.append(f"**Total Portfolio Value**: ${response.total_portfolio_value:.2f}")
+        output.append("")
+
+    # Add insights if present
+    if response.insights:
+        output.append("## Key Insights")
+        output.append("")
+        for insight in response.insights:
+            output.append(f"- {insight}")
+        output.append("")
+
+    return "\n".join(output).strip()
+
+
+class FinanceTrackerMCP:
+    """
+    Agent for managing personal investment portfolio using MCP Toolbox HTTP server.
+
+    Features:
+    - Portfolio Management: Track stock purchases/sales via Cloud SQL
+    - Position Analysis: View holdings, cost basis, realized gains
+    - Performance Metrics: Calculate gains/losses with current prices
+    - Database Operations: Full CRUD via MCP Toolbox Docker container
+    - Secure Access: Uses Google Cloud SQL with MCP Toolbox connector
+    """
+
+    def __init__(self):
+        self.name = "Finance Tracker (MCP)"
+        self.description = "Personal portfolio tracking and analysis using Cloud SQL via MCP Toolbox"
+        self.toolbox_client: Optional[ToolboxClient] = None
+        self.model: Optional[ChatGoogleGenerativeAI] = None
+        self.model_with_tools = None
+        self.model_structured = None
+        self.tools: List[Any] = []
+        self.tool_map: Dict[str, Any] = {}
+        self.initialized = False
+
+    async def initialize(self) -> None:
+        """Initialize the agent with MCP Toolbox HTTP server."""
+        print(f"💼 Initializing {self.name}...")
+
+        try:
+            # Connect to MCP Toolbox HTTP server (Docker container)
+            print(f"  📡 Connecting to MCP Toolbox HTTP server...")
+            print(f"    Server URL: {config.MCP_TOOLBOX_SERVER_URL}")
+
+            # Create toolbox client and enter async context manager
+            self.toolbox_client = ToolboxClient(config.MCP_TOOLBOX_SERVER_URL)
+            # Manually enter the async context manager to keep connection alive
+            await self.toolbox_client.__aenter__()
+
+            # Load database tools from toolbox
+            print("    Loading tools from MCP Toolbox...")
+            self.tools = self.toolbox_client.load_toolset()
+
+            if not self.tools:
+                raise RuntimeError(
+                    f"No tools available from MCP Toolbox server at {config.MCP_TOOLBOX_SERVER_URL}\n"
+                    f"Make sure the Docker container is running: docker-compose up -d"
+                )
+
+            self.tool_map = {tool.name: tool for tool in self.tools}
+
+            # Initialize Gemini chat model bound to tools
+            self.model = ChatGoogleGenerativeAI(
+                model="gemini-2.5-flash",
+                temperature=0.1,
+                google_api_key=config.GOOGLE_API_KEY,
+            )
+            self.model_with_tools = self.model.bind_tools(self.tools)
+
+            # Initialize model with structured output for final responses
+            self.model_structured = self.model.with_structured_output(PortfolioResponse)
+
+            print(f"  ✅ Connected to MCP Toolbox with {len(self.tools)} tools")
+            print(f"  📋 Available MCP Toolbox capabilities:")
+            print(f"    - Database queries (SELECT, INSERT, UPDATE, DELETE)")
+            print(f"    - Schema introspection (tables, columns, relationships)")
+            print(f"    - Transaction management")
+            print(f"    - Natural language to SQL conversion")
+            print(f"    Total: {len(self.tools)} tools available")
+
+            self.initialized = True
+            print(f"  ✅ {self.name} ready!")
+
+        except Exception as e:
+            import traceback
+            print(f"  ❌ Error initializing {self.name}: {e}")
+            print(f"  📋 Full error details:")
+            traceback.print_exc()
+            print(f"\n💡 Troubleshooting:")
+            print(f"   1. Make sure Docker is running")
+            print(f"   2. Start MCP Toolbox container: docker-compose up -d")
+            print(f"   3. Check container status: docker-compose ps")
+            print(f"   4. View container logs: docker-compose logs mcp-toolbox")
+            print(f"   5. Verify server is accessible: curl {config.MCP_TOOLBOX_SERVER_URL}/health")
+            raise
+
+    async def process(self, query: str, history: Optional[List[Dict[str, str]]] = None) -> Dict[str, Any]:
+        """Process a query using MCP Toolbox for Cloud SQL operations."""
+        try:
+            if not self.initialized:
+                await self.initialize()
+
+            print(f"\n💼 {self.name} processing: '{query}'")
+
+            # Build system message with portfolio context
+            system_message = """You are a Finance Tracker Agent specialized in portfolio management.
+
+You have access to a Cloud SQL PostgreSQL database through MCP Toolbox with the following schema:
+
+Tables:
+- stock_transactions: Stores all BUY/SELL transactions (symbol, transaction_type, quantity, price, transaction_date, notes)
+- portfolio_positions: Current aggregated positions (symbol, total_quantity, avg_cost_basis, total_invested, realized_gains)
+- portfolio_snapshots: Historical portfolio value tracking
+- stock_metadata: Cached stock information (company_name, sector, industry, market_cap)
+
+When users want to:
+- ADD a transaction: INSERT into stock_transactions (triggers will update portfolio_positions automatically)
+- VIEW portfolio: SELECT from portfolio_positions
+- CHECK transaction history: SELECT from stock_transactions
+- ANALYZE performance: Query portfolio_positions with calculations
+
+Always use the MCP Toolbox database tools to:
+1. Query the database for current data
+2. Insert/update records as needed
+3. Calculate metrics (gains, losses, allocations)
+4. Provide clear, actionable insights
+
+Be helpful, accurate, and provide investment insights based on their data."""
+
+            messages: List[Any] = [HumanMessage(content=system_message)]
+
+            # Add conversation history
+            if history:
+                trimmed_history = history[-10:]
+                for turn in trimmed_history:
+                    user_text = turn.get("user")
+                    if user_text:
+                        messages.append(HumanMessage(content=user_text))
+                    assistant_text = turn.get("assistant")
+                    if assistant_text:
+                        messages.append(AIMessage(content=assistant_text))
+
+            messages.append(HumanMessage(content=query))
+
+            # Tool calling loop - gather data from database
+            tool_calls_info = []
+            while True:
+                if not self.model_with_tools:
+                    raise RuntimeError("Model not initialized with tools")
+
+                ai_message = await self.model_with_tools.ainvoke(messages)
+                messages.append(ai_message)
+
+                tool_calls = getattr(ai_message, "tool_calls", [])
+                if not tool_calls:
+                    # No more tool calls - exit loop
+                    break
+
+                for call in tool_calls:
+                    tool_name = call.get("name")
+                    tool_args = call.get("args", {})
+                    tool_call_id = call.get("id")
+                    print(f"  🔧 MCP Toolbox call: {tool_name}({json.dumps(tool_args, indent=2)})")
+                    tool_calls_info.append(f"🔧 MCP Toolbox call: {tool_name}({json.dumps(tool_args)})")
+
+                    tool = self.tool_map.get(tool_name)
+                    if not tool:
+                        tool_result = {"error": f"Tool '{tool_name}' not found"}
+                    else:
+                        tool_result = await tool.ainvoke(tool_args)
+
+                    messages.append(
+                        ToolMessage(
+                            content=_to_text(tool_result),
+                            tool_call_id=tool_call_id or "",
+                        )
+                    )
+
+            # Generate structured response based on all gathered information
+            print("  📊 Generating structured response...")
+            structured_prompt = """Based on the database query results, provide a structured response.
+
+Guidelines:
+- For portfolio viewing: Set response_type to "portfolio_view" and populate holdings list
+- For adding transactions: Set response_type to "transaction_added" and populate transaction field
+- For transaction history: Set response_type to "transaction_history" and populate transactions list
+- For other queries: Set response_type to "general_response"
+- Always provide a clear summary
+- Include relevant insights when possible"""
+
+            messages.append(HumanMessage(content=structured_prompt))
+
+            if not self.model_structured:
+                raise RuntimeError("Structured output model not initialized")
+
+            structured_response = await self.model_structured.ainvoke(messages)
+
+            # Format the structured response into readable text
+            final_response = format_portfolio_response(structured_response)
+
+            return {
+                "success": True,
+                "agent": self.name,
+                "response": final_response,
+                "query": query,
+                "structured_data": structured_response.model_dump(),  # Include raw structured data
+                "tool_calls": tool_calls_info
+            }
+
+        except Exception as e:
+            print(f"  ❌ Error in {self.name}: {e}")
+            import traceback
+            traceback.print_exc()
+            return {
+                "success": False,
+                "agent": self.name,
+                "error": str(e),
+                "query": query
+            }
+
+    async def cleanup(self) -> None:
+        """Cleanup resources."""
+        if self.toolbox_client:
+            try:
+                # Exit the async context manager
+                await self.toolbox_client.__aexit__(None, None, None)
+            except Exception as e:
+                print(f"  ⚠️  Warning during cleanup: {e}")
+        print(f"🧹 {self.name} cleaned up")

src/agents/rag_agent_mcp.py

@@ -0,0 +1,449 @@
+"""RAG Agent using Chroma MCP Server via LangChain MCP adapters."""
+import json
+import os
+import shutil
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import chromadb
+from src.core.config import config
+from src.utils.file_processors import process_document
+from langchain_core.tools import BaseTool
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_mcp_adapters.client import MultiServerMCPClient
+
+
+class RAGAgentMCP:
+    """Agent specialized in document retrieval and Q&A using Chroma MCP Server."""
+
+    @staticmethod
+    def _to_text(payload: Any) -> str:
+        """Convert tool or model output into a displayable string."""
+        if isinstance(payload, str):
+            return payload
+        try:
+            return json.dumps(payload, ensure_ascii=False)
+        except TypeError:
+            return str(payload)
+
+    def __init__(self):
+        self.name = "RAG Agent (MCP)"
+        self.description = "Document storage, retrieval, and question answering expert using Chroma MCP Server"
+        # MCP Server client
+        self.mcp_client: Optional[MultiServerMCPClient] = None
+
+        # Direct ChromaDB client (for document upload only)
+        self.chroma_direct_client = None
+        self.collection = None
+
+        # Gemini model
+        self.model: Optional[ChatGoogleGenerativeAI] = None
+        self.model_with_tools = None
+        self.tools: List[BaseTool] = []
+        self.tool_map: Dict[str, BaseTool] = {}
+
+    async def initialize(self) -> None:
+        """Initialize the agent with direct ChromaDB client."""
+        print(f"🔧 Initializing {self.name}...")
+
+        try:
+            # MCP Server integration commented out - using direct client instead
+            # # 1. Connect to Chroma MCP Server for tool access
+            # print(f"  📡 Connecting to Chroma MCP Server...")
+            # chroma_connection = self._build_chroma_connection()
+            # self.mcp_client = MultiServerMCPClient({"chroma": chroma_connection})
+            #
+            # # Get tools from MCP server
+            # self.tools = await self.mcp_client.get_tools(server_name="chroma")
+            # if not self.tools:
+            #     raise RuntimeError("No tools returned by Chroma MCP server")
+            #
+            # self.tool_map = {tool.name: tool for tool in self.tools}
+            #
+            # print(f"  ✅ Connected to Chroma MCP Server with {len(self.tools)} tools")
+
+            # 1. Connect to ChromaDB Cloud with direct client
+            print(f"  📚 Connecting to ChromaDB Cloud...")
+            self.chroma_direct_client = chromadb.CloudClient(
+                tenant=config.CHROMA_TENANT,
+                database=config.CHROMA_DATABASE,
+                api_key=config.CHROMA_API_KEY
+            )
+
+            # 2. Use Google Gemini embedding function
+            print(f"  🔧 Setting up Gemini embeddings...")
+            from chromadb.utils.embedding_functions import GoogleGenerativeAiEmbeddingFunction
+            embedding_function = GoogleGenerativeAiEmbeddingFunction(
+                api_key=config.GOOGLE_API_KEY,
+                model_name="models/embedding-001"
+            )
+
+            # 3. Get or create collection with Gemini embeddings
+            collection_name = "gemini-embed"
+            self.collection = self.chroma_direct_client.get_or_create_collection(
+                name=collection_name,
+                metadata={"description": "Document storage for RAG with Gemini embeddings"},
+                embedding_function=embedding_function
+            )
+            print(f"  📦 Using collection: {collection_name}")
+            print(f"  📄 Current documents in collection: {self.collection.count()}")
+
+            # 4. Initialize Gemini model for answer generation
+            self.model = ChatGoogleGenerativeAI(
+                model="gemini-2.5-flash",
+                temperature=0.1,
+                google_api_key=config.GOOGLE_API_KEY,
+            )
+            
+
+            print(f"  ✅ {self.name} ready!")
+
+        except Exception as e:
+            import traceback
+            print(f"  ❌ Error initializing {self.name}: {e}")
+            print(f"  📋 Full error details:")
+            traceback.print_exc()
+            raise
+
+    async def add_document(
+        self,
+        file_path: str,
+        metadata: Optional[Dict[str, Any]] = None,
+        progress_callback: Optional[callable] = None
+    ) -> Dict[str, Any]:
+        """
+        Add a document to ChromaDB via MCP server.
+
+        Note: This uses direct ChromaDB client as MCP add_documents tool
+        requires the collection to already exist and documents to be processed.
+
+        Args:
+            file_path: Path to the document file
+            metadata: Optional metadata for the document
+            progress_callback: Optional callback for progress updates
+
+        Returns:
+            Dictionary with status and document info
+        """
+        try:
+            doc_path = Path(file_path)
+
+            # Validate file type
+            if doc_path.suffix.lower() not in config.ALLOWED_FILE_TYPES:
+                return {
+                    "success": False,
+                    "error": f"Unsupported file type: {doc_path.suffix}. Allowed: {config.ALLOWED_FILE_TYPES}"
+                }
+
+            print(f"\n📄 Processing {doc_path.suffix.upper()}: {doc_path.name}")
+
+            if progress_callback:
+                progress_callback(0.1, "Extracting text from document...")
+
+            # Process document using file_processors
+            doc_info = process_document(doc_path, chunk_size=500, overlap=50)
+
+            if progress_callback:
+                progress_callback(0.4, f"Extracted {doc_info['num_chunks']} chunks...")
+
+            # Generate document ID
+            doc_id = doc_path.stem
+
+            # Prepare metadata
+            doc_metadata = {
+                "filename": doc_info["filename"],
+                "file_type": doc_info["file_type"],
+                "file_size": doc_info["file_size"],
+                "num_chunks": doc_info["num_chunks"],
+                "source": "user_upload",
+                **(metadata or {})
+            }
+
+            # MCP Server upload (commented out - using direct client instead)
+            # if progress_callback:
+            #     progress_callback(0.6, "Uploading via Chroma MCP Server...")
+            #
+            # # Prepare data for MCP add_documents tool
+            # chunks = doc_info["chunks"]
+            # ids = [f"{doc_id}_chunk_{i}" for i in range(len(chunks))]
+            # metadatas = [
+            #     {**doc_metadata, "chunk_index": i, "chunk_id": ids[i]}
+            #     for i in range(len(chunks))
+            # ]
+            #
+            # # Try using MCP server's add_documents tool
+            # add_tool = (
+            #     self.tool_map.get("chroma_add_documents")
+            #     or self.tool_map.get("add_documents")
+            # )
+            # if not add_tool:
+            #     raise KeyError("add_documents tool not available in Chroma MCP")
+            #
+            # tool_payload = {
+            #     "collection_name": "gemini-embed",  # Use dedicated Gemini collection
+            #     "documents": chunks,
+            #     "ids": ids,
+            #     "metadatas": metadatas,
+            # }
+            #
+            # result = await add_tool.ainvoke(tool_payload)
+            #
+            # if isinstance(result, dict) and result.get("success"):
+            #     print(f"  ✅ Added via MCP: {len(chunks)} chunks from {doc_path.name}")
+            # else:
+            #     raise ValueError(result)
+
+            # Direct ChromaDB client upload
+            if progress_callback:
+                progress_callback(0.6, "Uploading to ChromaDB with Google embeddings...")
+
+            chunks = doc_info["chunks"]
+            ids = [f"{doc_id}_chunk_{i}" for i in range(len(chunks))]
+            metadatas = [
+                {**doc_metadata, "chunk_index": i, "chunk_id": ids[i]}
+                for i in range(len(chunks))
+            ]
+
+            self.collection.add(
+                documents=chunks,
+                ids=ids,
+                metadatas=metadatas
+            )
+            print(f"  ✅ Added {len(chunks)} chunks from {doc_path.name} to '{self.collection.name}'")
+
+            if progress_callback:
+                progress_callback(1.0, "Upload complete!")
+
+            return {
+                "success": True,
+                "document_id": doc_id,
+                "filename": doc_path.name,
+                "file_type": doc_info["file_type"],
+                "chunks_added": len(chunks),
+                "total_documents": self.collection.count()
+            }
+
+        except Exception as e:
+            print(f"  ❌ Error adding document: {e}")
+            import traceback
+            traceback.print_exc()
+            return {
+                "success": False,
+                "error": str(e)
+            }
+
+    async def process(self, query: str, history: Optional[List[Dict[str, str]]] = None) -> Dict[str, Any]:
+        """Process a query using direct ChromaDB client and Gemini."""
+        try:
+            print(f"\n📚 {self.name} processing: '{query}'")
+
+            # MCP Tool-based approach (commented out - using direct client instead)
+            # if not self.model_with_tools:
+            #     raise RuntimeError("Model not initialized with tools")
+            #
+            # messages: List[Any] = [HumanMessage(content=query)]
+            # final_response = ""
+            #
+            # while True:
+            #     ai_message = await self.model_with_tools.ainvoke(messages)
+            #     messages.append(ai_message)
+            #
+            #     tool_calls = getattr(ai_message, "tool_calls", [])
+            #     if not tool_calls:
+            #         final_response = self._to_text(ai_message.content)
+            #         break
+            #
+            #     for call in tool_calls:
+            #         tool_name = call.get("name")
+            #         tool_args = call.get("args", {})
+            #         tool_call_id = call.get("id")
+            #         print(f"  🔧 MCP Tool call: {tool_name}({tool_args})")
+            #
+            #         tool = self.tool_map.get(tool_name)
+            #         if not tool:
+            #             tool_result = {"error": f"Tool '{tool_name}' not found"}
+            #         else:
+            #             tool_result = await tool.ainvoke(tool_args)
+            #
+            #         messages.append(
+            #             ToolMessage(
+            #                 content=self._to_text(tool_result),
+            #                 tool_call_id=tool_call_id or "",
+            #             )
+            #         )
+
+            # Direct ChromaDB query approach
+            if not self.model:
+                raise RuntimeError("Model not initialized")
+
+            conversation_context = ""
+            if history:
+                trimmed_history = history[-6:]
+                history_lines: List[str] = []
+                for turn in trimmed_history:
+                    user_text = turn.get("user", "")
+                    # Handle both string and list types
+                    if isinstance(user_text, str):
+                        user_text = user_text.strip()
+                    elif isinstance(user_text, list):
+                        user_text = " ".join(str(x) for x in user_text).strip()
+                    else:
+                        user_text = str(user_text).strip()
+                    
+                    if user_text:
+                        history_lines.append(f"User: {user_text}")
+                    
+                    assistant_text = turn.get("assistant", "")
+                    # Handle both string and list types
+                    if isinstance(assistant_text, str):
+                        assistant_text = assistant_text.strip()
+                    elif isinstance(assistant_text, list):
+                        assistant_text = " ".join(str(x) for x in assistant_text).strip()
+                    else:
+                        assistant_text = str(assistant_text).strip()
+                    
+                    if assistant_text:
+                        history_lines.append(f"Assistant: {assistant_text}")
+                if history_lines:
+                    conversation_context = "\n".join(history_lines)
+
+            conversational_query = query
+            if conversation_context:
+                try:
+                    rephrase_prompt = f"""You are a helpful assistant that rewrites follow-up questions.
+Use the provided conversation history to rewrite the latest user input so it is a standalone question for document retrieval.
+
+Conversation history:
+{conversation_context}
+
+Latest user input: {query}
+
+Respond with only the rewritten standalone question."""
+
+                    # Stream the rephrase response
+                    candidate_content = ""
+                    async for chunk in self.model.astream(rephrase_prompt):
+                        if hasattr(chunk, 'content') and chunk.content:
+                            candidate_content += chunk.content
+
+                    candidate = candidate_content.strip()
+                    if candidate:
+                        conversational_query = candidate
+                except Exception as rephrase_error:
+                    print(f"  ⚠️ Could not rewrite query from history: {rephrase_error}")
+
+            # Query the collection with Google embeddings
+            print(f"  🔍 Querying collection '{self.collection.name}'...")
+            results = self.collection.query(
+                query_texts=[conversational_query],
+                n_results=5  # Get top 5 most relevant chunks
+            )
+
+            # Extract documents and metadata
+            documents = results.get('documents', [[]])[0]
+            metadatas = results.get('metadatas', [[]])[0]
+            distances = results.get('distances', [[]])[0]
+
+            if not documents:
+                print(f"  ⚠️ No relevant documents found")
+                return {
+                    "success": True,
+                    "agent": self.name,
+                    "response": "I couldn't find any relevant information in the uploaded documents to answer your question.",
+                    "query": query
+                }
+
+            print(f"  📄 Found {len(documents)} relevant chunks")
+
+            # Build context from retrieved documents
+            context = "\n\n".join([
+                f"[Document: {meta.get('filename', 'Unknown')} - Chunk {meta.get('chunk_index', '?')}]\n{doc}"
+                for doc, meta in zip(documents, metadatas)
+            ])
+
+            # Create prompt with context
+            history_section = f"Conversation history:\n{conversation_context}\n\n" if conversation_context else ""
+            prompt = f"""Based on the following document excerpts, please answer the question.
+
+{history_section}Context from documents:
+{context}
+
+Question: {conversational_query}
+Original user input: {query}
+
+Please provide a comprehensive answer based on the context above. If the context doesn't contain enough information to answer the question, please say so."""
+
+            # Generate answer using Gemini with streaming
+            print(f"  🤖 Streaming answer from Gemini...")
+            final_response = ""
+            async for chunk in self.model.astream(prompt):
+                if hasattr(chunk, 'content') and chunk.content:
+                    final_response += chunk.content
+
+            return {
+                "success": True,
+                "agent": self.name,
+                "response": final_response,
+                "query": query,
+                "interpreted_query": conversational_query,
+                "sources": [meta.get('filename') for meta in metadatas]
+            }
+
+        except Exception as e:
+            print(f"  ❌ Error in {self.name}: {e}")
+            import traceback
+            traceback.print_exc()
+            return {
+                "success": False,
+                "agent": self.name,
+                "error": str(e),
+                "query": query
+            }
+
+    async def cleanup(self) -> None:
+        """Cleanup resources."""
+        print(f"🧹 {self.name} cleaned up")
+
+    def _build_chroma_connection(self) -> Dict[str, Any]:
+        """Create connection configuration for the Chroma MCP server."""
+        env = {
+            "CHROMA_CLIENT_TYPE": "cloud",
+            "CHROMA_TENANT": config.CHROMA_TENANT or "",
+            "CHROMA_DATABASE": config.CHROMA_DATABASE or "",
+            "CHROMA_API_KEY": config.CHROMA_API_KEY or "",
+            "CHROMA_CLOUD_HOST": config.CHROMA_CLOUD_HOST,
+        }
+
+        scripts_dir = Path(sys.prefix) / ("Scripts" if os.name == "nt" else "bin")
+        candidates = [
+            str(scripts_dir / "uvx.exe"),
+            str(scripts_dir / "uvx.cmd"),
+            str(scripts_dir / "uvx"),
+            "uvx.exe",
+            "uvx.cmd",
+            "uvx",
+        ]
+
+        uvx_path: Optional[str] = None
+        for candidate in candidates:
+            if not candidate:
+                continue
+            resolved = shutil.which(candidate)
+            if resolved:
+                uvx_path = resolved
+                break
+
+        if not uvx_path:
+            msg = (
+                "Could not locate 'uvx'. Install the 'uv' package inside the virtual "
+                "environment or ensure it is on PATH."
+            )
+            raise FileNotFoundError(msg)
+
+        return {
+            "transport": "stdio",
+            "command": uvx_path,
+            "args": ["--with", "onnxruntime", "chroma-mcp", "--client-type", "cloud"],
+            "env": env,
+        }

src/agents/search_agent_mcp.py

@@ -0,0 +1,283 @@
+"""Search Agent using DuckDuckGo MCP Server via uvx."""
+import asyncio
+from typing import Dict, Any, Optional, List
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_core.messages import HumanMessage, SystemMessage, AIMessage, ToolMessage
+from langchain_core.tools import BaseTool
+from langchain_mcp_adapters.client import MultiServerMCPClient
+from src.core.config import config
+
+
+class SearchAgentMCP:
+    """
+    Agent for performing web searches using DuckDuckGo MCP Server via uvx.
+    Follows the same pattern as StockAgentMCP using langchain-mcp-adapters.
+    """
+
+    def __init__(self):
+        """Initialize the DuckDuckGo search agent."""
+        self.name = "Search Agent (MCP)"
+        self.description = "Web search expert using DuckDuckGo MCP Server via uvx"
+        self.mcp_client: Optional[MultiServerMCPClient] = None
+        self.llm: Optional[ChatGoogleGenerativeAI] = None
+        self.llm_with_tools = None
+        self.tools: List[BaseTool] = []
+        self.tool_map: Dict[str, BaseTool] = {}
+        self.initialized = False
+
+    async def initialize(self):
+        """Initialize the agent with MCP client and LLM."""
+        if not self.initialized:
+            print("🔍 Initializing Search Agent (MCP)...")
+
+            try:
+                # Connect to DuckDuckGo MCP Server via uvx
+                print("  📡 Connecting to DuckDuckGo MCP Server...")
+
+                connection_name = "duckduckgo"
+                connections: Dict[str, Dict[str, Any]] = {}
+
+                # DuckDuckGo MCP Server via uvx (Python package)
+                # This works inside Docker containers without Docker-in-Docker
+                connections[connection_name] = {
+                    "transport": "stdio",
+                    "command": "uvx",
+                    "args": ["duckduckgo-mcp-server"],
+                }
+
+                print("    Using DuckDuckGo MCP server via uvx...")
+
+                self.mcp_client = MultiServerMCPClient(connections)
+
+                # Load MCP tools as LangChain tools
+                print("    Loading tools from DuckDuckGo MCP Server...")
+                self.tools = await self.mcp_client.get_tools(server_name=connection_name)
+
+                if not self.tools:
+                    raise RuntimeError(
+                        "No tools available from DuckDuckGo MCP Server\n"
+                        "Make sure uvx is available and duckduckgo-mcp-server can be installed:\n"
+                        "  - Check: uvx --version\n"
+                        "  - Test: uvx duckduckgo-mcp-server --help"
+                    )
+
+                self.tool_map = {tool.name: tool for tool in self.tools}
+
+                # Initialize Gemini chat model bound to tools
+                self.llm = ChatGoogleGenerativeAI(
+                    model="gemini-2.5-flash",
+                    temperature=0.3,
+                    google_api_key=config.GOOGLE_API_KEY,
+                )
+                self.llm_with_tools = self.llm.bind_tools(self.tools)
+
+                print(f"  ✅ Connected to DuckDuckGo MCP Server")
+                print(f"  📋 Available tools: {len(self.tools)}")
+                for tool in self.tools:
+                    print(f"    - {tool.name}")
+                print(f"  ✅ Bound {len(self.tools)} tools to LLM")
+
+                self.initialized = True
+                print("  ✅ Search Agent (MCP) ready!")
+
+            except Exception as e:
+                import traceback
+                print(f"  ❌ Error initializing Search Agent: {e}")
+                print(f"  📋 Full error details:")
+                traceback.print_exc()
+                print(f"\n💡 Troubleshooting:")
+                print(f"   1. Make sure Docker is running: docker ps")
+                print(f"   2. Test Docker: docker run --rm hello-world")
+                print(f"   3. Pull the image manually: docker pull mcp/duckduckgo")
+                print(f"   4. Check Docker is in PATH: where docker (Windows) or which docker (Linux/Mac)")
+                raise
+
+    async def process(
+        self,
+        query: str,
+        history: Optional[List[Dict[str, str]]] = None
+    ) -> Dict[str, Any]:
+        """
+        Process a search query through the DuckDuckGo MCP server.
+
+        Args:
+            query: User's search query
+            history: Optional conversation history
+
+        Returns:
+            Dictionary with agent response and optional search_urls
+        """
+        try:
+            if not self.initialized:
+                await self.initialize()
+
+            print(f"\n🔍 Search Agent processing: '{query}'")
+
+            # Build system prompt
+            system_prompt = """You are a web search assistant with access to DuckDuckGo search.
+
+CRITICAL: You MUST use the available tools to find current information. DO NOT answer from memory.
+
+Your process:
+1. Use the search tool with the user's query
+2. Read the search results carefully
+3. Synthesize a clear, accurate answer with source citations
+
+Always use the search tool first before answering."""
+
+            # Prepare messages
+            messages = [SystemMessage(content=system_prompt)]
+
+            # Add conversation history if provided (limit to last 2 turns)
+            if history:
+                for turn in history[-2:]:
+                    if "user" in turn:
+                        messages.append(HumanMessage(content=turn["user"]))
+                    if "assistant" in turn:
+                        messages.append(AIMessage(content=turn["assistant"]))
+
+            # Add current query
+            messages.append(HumanMessage(content=query))
+
+            # Track search URLs for references
+            search_urls = []
+            tool_calls_info = []
+
+            # Tool calling loop
+            max_iterations = 3
+            for iteration in range(max_iterations):
+                # Get LLM response
+                response = await self.llm_with_tools.ainvoke(messages)
+                messages.append(response)
+
+                # Check for tool calls
+                tool_calls = getattr(response, 'tool_calls', None) or []
+
+                if not tool_calls:
+                    # No more tool calls, return final response
+                    final_content = response.content if hasattr(response, 'content') else str(response)
+                    print(f"  ✅ Search complete")
+                    result = {
+                        "success": True,
+                        "response": final_content
+                    }
+                    if search_urls:
+                        result["search_urls"] = search_urls
+                    if tool_calls_info:
+                        result["tool_calls"] = tool_calls_info
+                    return result
+
+                # Execute tool calls
+                for tool_call in tool_calls:
+                    # Handle both dict and object formats
+                    if isinstance(tool_call, dict):
+                        tool_name = tool_call.get('name', '')
+                        tool_args = tool_call.get('args', {})
+                        tool_id = tool_call.get('id', '')
+                    else:
+                        tool_name = getattr(tool_call, 'name', '')
+                        tool_args = getattr(tool_call, 'args', {})
+                        tool_id = getattr(tool_call, 'id', '')
+
+                    print(f"  🔧 Executing: {tool_name}({tool_args})")
+                    tool_calls_info.append(f"🔧 DuckDuckGo call: {tool_name}({tool_args})")
+
+                    # Get the tool
+                    tool = self.tool_map.get(tool_name)
+                    if not tool:
+                        tool_result = f"Error: Tool '{tool_name}' not found"
+                    else:
+                        try:
+                            # Call the tool with timeout
+                            tool_result = await asyncio.wait_for(
+                                tool.ainvoke(tool_args),
+                                timeout=30.0
+                            )
+                            print(f"  ✅ Tool executed successfully")
+
+                            # Extract URLs from search results (safely)
+                            if tool_name == "search":
+                                try:
+                                    # Print the raw result to see format
+                                    print(f"  📄 Search result type: {type(tool_result)}")
+
+                                    # Convert to string if needed
+                                    result_str = str(tool_result) if not isinstance(tool_result, str) else tool_result
+
+                                    # Parse search results to extract URLs
+                                    import re
+                                    # Look for URL patterns in the result
+                                    url_pattern = r'https?://[^\s<>"{}|\\^`\[\]]+'
+                                    found_urls = re.findall(url_pattern, result_str)
+
+                                    # Add unique URLs
+                                    for url in found_urls[:5]:  # Top 5 URLs
+                                        try:
+                                            # Extract domain as title
+                                            domain = url.split('/')[2] if len(url.split('/')) > 2 else url
+                                            url_data = {"url": url, "title": domain}
+                                            if url_data not in search_urls:
+                                                search_urls.append(url_data)
+                                                print(f"  🔗 Found URL: {url}")
+                                        except Exception as e:
+                                            print(f"  ⚠️ Error parsing URL {url}: {e}")
+                                            continue
+                                except Exception as e:
+                                    print(f"  ⚠️ Error extracting URLs: {e}")
+                                    # Continue anyway, don't break search functionality
+
+                            # Truncate if too long
+                            if isinstance(tool_result, str) and len(tool_result) > 5000:
+                                tool_result = tool_result[:5000] + "\n\n[Results truncated]"
+                            elif isinstance(tool_result, dict):
+                                result_str = str(tool_result)
+                                if len(result_str) > 5000:
+                                    tool_result = result_str[:5000] + "\n\n[Results truncated]"
+
+                        except asyncio.TimeoutError:
+                            tool_result = "Error: Search timed out"
+                            print(f"  ⚠️ Tool call timed out")
+                        except Exception as e:
+                            tool_result = f"Error: {str(e)}"
+                            print(f"  ❌ Tool execution failed: {e}")
+
+                    # Add tool result to messages
+                    messages.append(
+                        ToolMessage(
+                            content=str(tool_result),
+                            tool_call_id=tool_id
+                        )
+                    )
+
+            # If we hit max iterations, return last response
+            print(f"  ⚠️ Max iterations reached")
+            result = {
+                "success": True,
+                "response": "Search completed but may be incomplete. Try a more specific query."
+            }
+            if search_urls:
+                result["search_urls"] = search_urls
+            if tool_calls_info:
+                result["tool_calls"] = tool_calls_info
+            return result
+
+        except Exception as e:
+            error_msg = f"Error processing search query: {str(e)}"
+            print(f"  ❌ {error_msg}")
+            import traceback
+            print(f"  Traceback: {traceback.format_exc()}")
+            return {
+                "success": False,
+                "error": error_msg,
+                "response": f"I encountered an error: {str(e)}"
+            }
+
+    async def cleanup(self):
+        """Cleanup resources."""
+        if self.mcp_client:
+            try:
+                await self.mcp_client.cleanup()
+            except Exception as e:
+                print(f"  ⚠️ Warning during cleanup: {e}")
+        self.initialized = False
+        print("🧹 Search Agent cleanup complete")

src/agents/stock_agent_mcp.py

@@ -0,0 +1,196 @@
+"""Stock Agent using Alpha Vantage MCP Server via LangChain MCP adapters."""
+import json
+import shutil
+from typing import Any, Dict, List, Optional
+
+from src.core.config import config
+from langchain_core.messages import AIMessage, HumanMessage, ToolMessage
+from langchain_core.tools import BaseTool
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_mcp_adapters.client import MultiServerMCPClient
+
+
+def _resolve_executable(candidates: List[str]) -> str:
+    """Return first executable path found in PATH."""
+    for name in candidates:
+        resolved = shutil.which(name)
+        if resolved:
+            return resolved
+    raise FileNotFoundError(f"Unable to locate any of: {', '.join(candidates)}")
+
+
+def _to_text(payload: Any) -> str:
+    """Convert model or tool output into a printable string."""
+    if isinstance(payload, str):
+        return payload
+    try:
+        return json.dumps(payload, ensure_ascii=False)
+    except TypeError:
+        return str(payload)
+
+
+class StockAgentMCP:
+    """Agent specialized in stock market data using Alpha Vantage MCP Server."""
+
+    def __init__(self):
+        self.name = "Stock Agent (MCP)"
+        self.description = "Stock market data and analysis expert using Alpha Vantage MCP Server"
+        self.mcp_client: Optional[MultiServerMCPClient] = None
+        self.model: Optional[ChatGoogleGenerativeAI] = None
+        self.model_with_tools = None
+        self.tools: List[BaseTool] = []
+        self.tool_map: Dict[str, BaseTool] = {}
+
+    async def initialize(self) -> None:
+        """Initialize the agent with Alpha Vantage MCP Server."""
+        print(f"📧 Initializing {self.name}...")
+
+        try:
+            # Connect to Alpha Vantage MCP Server
+            print(f"  📡 Connecting to Alpha Vantage MCP Server...")
+
+            connection_name = "alphavantage"
+            connections: Dict[str, Dict[str, Any]] = {}
+
+            api_key = (config.ALPHA_VANTAGE_API_KEY or "").strip()
+            if not api_key:
+                raise ValueError(
+                    "ALPHA_VANTAGE_API_KEY not configured in .env file.\n"
+                    "Get your free API key from: https://www.alphavantage.co/support/#api-key"
+                )
+
+            print("    Using Alpha Vantage local MCP server via uvx...")
+            
+            # Try to find uvx executable (uv's command runner)
+            try:
+                uvx_executable = _resolve_executable(["uvx.exe", "uvx.cmd", "uvx"])
+                print(f"    Found uvx at: {uvx_executable}")
+            except FileNotFoundError:
+                raise ValueError(
+                    "uvx not found. Please install uv (Python package manager) from:\n"
+                    "  Windows: pip install uv\n"
+                    "  Or visit: https://docs.astral.sh/uv/getting-started/installation/\n"
+                    "After installing, restart your terminal/IDE."
+                )
+            
+            # Alpha Vantage MCP uses stdio transport with uvx av-mcp
+            connections[connection_name] = {
+                "transport": "stdio",
+                "command": uvx_executable,
+                "args": ["av-mcp", api_key],
+            }
+
+            self.mcp_client = MultiServerMCPClient(connections)
+
+            # Load MCP tools as LangChain tools
+            print("    Loading tools from Alpha Vantage MCP Server...")
+            all_tools = await self.mcp_client.get_tools(server_name=connection_name)
+            if not all_tools:
+                raise RuntimeError("No tools available from Alpha Vantage MCP Server")
+
+            # Exclude REALTIME_BULK_QUOTES tool
+            self.tools = [tool for tool in all_tools if tool.name != "REALTIME_BULK_QUOTES"]
+            print(f"    Excluded REALTIME_BULK_QUOTES tool")
+
+            self.tool_map = {tool.name: tool for tool in self.tools}
+
+            # Initialize Gemini chat model bound to tools
+            self.model = ChatGoogleGenerativeAI(
+                model="gemini-2.5-flash",
+                temperature=0.1,
+                google_api_key=config.GOOGLE_API_KEY,
+            )
+            self.model_with_tools = self.model.bind_tools(self.tools)
+
+            print(f"  ✅ Connected to Alpha Vantage MCP Server with {len(self.tools)} tools")
+            print(f"  📋 Available tool categories:")
+            
+            # Group tools by category for better display
+            tool_names = [tool.name for tool in self.tools]
+            print(f"    - Core Stock APIs: TIME_SERIES_*, GLOBAL_QUOTE, SYMBOL_SEARCH, etc.")
+            print(f"    - Fundamental Data: COMPANY_OVERVIEW, INCOME_STATEMENT, etc.")
+            print(f"    - Alpha Intelligence: NEWS_SENTIMENT, TOP_GAINERS_LOSERS, etc.")
+            print(f"    - Technical Indicators: RSI, MACD, SMA, EMA, etc.")
+            print(f"    Total: {len(self.tools)} tools available")
+
+            print(f"  ✅ {self.name} ready!")
+
+        except Exception as e:
+            import traceback
+            print(f"  ❌ Error initializing {self.name}: {e}")
+            print(f"  📋 Full error details:")
+            traceback.print_exc()
+            raise
+
+    async def process(self, query: str, history: Optional[List[Dict[str, str]]] = None) -> Dict[str, Any]:
+        """Process a query using Alpha Vantage MCP Server tools."""
+        try:
+            print(f"\n📈 {self.name} processing: '{query}'")
+            messages: List[Any] = []
+            if history:
+                trimmed_history = history[-10:]
+                for turn in trimmed_history:
+                    user_text = turn.get("user")
+                    if user_text:
+                        messages.append(HumanMessage(content=user_text))
+                    assistant_text = turn.get("assistant")
+                    if assistant_text:
+                        messages.append(AIMessage(content=assistant_text))
+            messages.append(HumanMessage(content=query))
+            final_response = ""
+            tool_calls_info = []
+
+            while True:
+                if not self.model_with_tools:
+                    raise RuntimeError("Model not initialized with tools")
+
+                ai_message = await self.model_with_tools.ainvoke(messages)
+                messages.append(ai_message)
+
+                tool_calls = getattr(ai_message, "tool_calls", [])
+                if not tool_calls:
+                    final_response = _to_text(ai_message.content)
+                    break
+
+                for call in tool_calls:
+                    tool_name = call.get("name")
+                    tool_args = call.get("args", {})
+                    tool_call_id = call.get("id")
+                    print(f"  🔧 MCP Tool call: {tool_name}({tool_args})")
+                    tool_calls_info.append(f"🔧 MCP Tool call: {tool_name}({tool_args})")
+
+                    tool = self.tool_map.get(tool_name)
+                    if not tool:
+                        tool_result = {"error": f"Tool '{tool_name}' not found"}
+                    else:
+                        tool_result = await tool.ainvoke(tool_args)
+
+                    messages.append(
+                        ToolMessage(
+                            content=_to_text(tool_result),
+                            tool_call_id=tool_call_id or "",
+                        )
+                    )
+
+            return {
+                "success": True,
+                "agent": self.name,
+                "response": final_response,
+                "query": query,
+                "tool_calls": tool_calls_info
+            }
+
+        except Exception as e:
+            print(f"  ❌ Error in {self.name}: {e}")
+            import traceback
+            traceback.print_exc()
+            return {
+                "success": False,
+                "agent": self.name,
+                "error": str(e),
+                "query": query
+            }
+
+    async def cleanup(self) -> None:
+        """Cleanup resources."""
+        print(f"🧹 {self.name} cleaned up")

src/api/main.py

@@ -0,0 +1,450 @@
+"""FastAPI application exposing multi-agent system via REST API."""
+import asyncio
+import json
+from typing import List, Dict, Optional
+from fastapi import FastAPI, UploadFile, File, HTTPException, WebSocket, WebSocketDisconnect
+from fastapi.responses import StreamingResponse
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field
+from pathlib import Path
+import tempfile
+import os
+
+from src.agents.crypto_agent_mcp import CryptoAgentMCP
+from src.agents.rag_agent_mcp import RAGAgentMCP
+from src.agents.stock_agent_mcp import StockAgentMCP
+from src.agents.search_agent_mcp import SearchAgentMCP
+from src.agents.finance_tracker_agent_mcp import FinanceTrackerMCP
+from src.core.langgraph_supervisor import ReActSupervisor
+
+
+# ============================================================================
+# Pydantic Models
+# ============================================================================
+
+class ChatMessage(BaseModel):
+    """Chat message model."""
+    role: str = Field(..., description="Role: 'user' or 'assistant'")
+    content: str = Field(..., description="Message content")
+
+
+class ChatRequest(BaseModel):
+    """Request model for chat endpoint."""
+    message: str = Field(..., description="User's query message")
+    history: Optional[List[ChatMessage]] = Field(default=[], description="Chat history")
+
+
+class ChatResponse(BaseModel):
+    """Response model for non-streaming chat."""
+    response: str = Field(..., description="Assistant's response")
+    history: List[ChatMessage] = Field(..., description="Updated chat history")
+
+
+class StreamEvent(BaseModel):
+    """Streaming event model."""
+    type: str = Field(..., description="Event type: thinking, action, observation, final_start, final_token, final_complete, error")
+    data: Dict = Field(default={}, description="Event data")
+
+
+class UploadResponse(BaseModel):
+    """Response model for document upload."""
+    success: bool = Field(..., description="Upload success status")
+    message: str = Field(..., description="Status message")
+    details: Optional[Dict] = Field(default=None, description="Upload details")
+
+
+class HealthResponse(BaseModel):
+    """Health check response."""
+    status: str = Field(..., description="System status")
+    initialized: bool = Field(..., description="Whether system is initialized")
+    agents: Dict[str, bool] = Field(..., description="Status of each agent")
+
+
+# ============================================================================
+# Multi-Agent Application
+# ============================================================================
+
+class MultiAgentApp:
+    """Main application orchestrating LLM supervisor and agents."""
+
+    def __init__(self):
+        self.crypto_agent = CryptoAgentMCP()
+        self.rag_agent = RAGAgentMCP()
+        self.stock_agent = StockAgentMCP()
+        self.search_agent = SearchAgentMCP()
+        self.finance_tracker = FinanceTrackerMCP()
+        self.supervisor = None
+        self.chat_history: List[Dict[str, str]] = []
+        self.initialized = False
+
+    async def initialize(self):
+        """Initialize all agents and supervisor with parallel initialization."""
+        if not self.initialized:
+            print("🚀 Initializing Multi-Agent System...")
+            print("⚡ Using parallel initialization for faster startup...")
+
+            # Initialize all agents in parallel
+            init_tasks = [
+                self.crypto_agent.initialize(),
+                self.rag_agent.initialize(),
+                self.stock_agent.initialize(),
+                self.search_agent.initialize(),
+                self.finance_tracker.initialize()
+            ]
+            
+            # Execute all initializations concurrently
+            results = await asyncio.gather(*init_tasks, return_exceptions=True)
+            
+            # Check for initialization failures
+            failed_agents = []
+            agent_names = ["Crypto", "RAG", "Stock", "Search", "Finance Tracker"]
+            for i, result in enumerate(results):
+                if isinstance(result, Exception):
+                    print(f"  ⚠️ {agent_names[i]} agent initialization failed: {result}")
+                    failed_agents.append(agent_names[i])
+            
+            if failed_agents:
+                print(f"  ⚠️ Some agents failed to initialize: {', '.join(failed_agents)}")
+                print("  ℹ️ System will continue with available agents")
+
+            # Initialize supervisor with agent references
+            self.supervisor = ReActSupervisor(
+                crypto_agent=self.crypto_agent,
+                rag_agent=self.rag_agent,
+                stock_agent=self.stock_agent,
+                search_agent=self.search_agent,
+                finance_tracker=self.finance_tracker
+            )
+
+            self.initialized = True
+            print("✅ System initialized with LangGraph supervisor!")
+            return "✅ All agents initialized and ready!"
+
+    async def process_query_streaming(self, message: str, history: List[Dict[str, str]]):
+        """
+        Process user query with streaming updates.
+
+        Args:
+            message: User's input message
+            history: Chat history in internal format [{"user": "...", "assistant": "..."}]
+
+        Yields:
+            Dictionary updates from supervisor
+        """
+        if not message.strip():
+            yield {"type": "error", "error": "Please enter a query."}
+            return
+
+        try:
+            # Check if system is initialized
+            if not self.initialized:
+                yield {"type": "error", "error": "System not initialized."}
+                return
+
+            # Stream updates from supervisor
+            async for update in self.supervisor.process_streaming(message, history=history):
+                yield update
+
+            # Update chat history
+            self.chat_history.append({"user": message})
+            if len(self.chat_history) > 20:
+                self.chat_history = self.chat_history[-20:]
+
+        except Exception as e:
+            yield {"type": "error", "error": str(e)}
+
+    async def upload_document(self, file_path: str, filename: str) -> Dict:
+        """
+        Handle document upload to ChromaDB Cloud.
+
+        Args:
+            file_path: Path to the uploaded file
+            filename: Original filename
+
+        Returns:
+            Upload result dictionary
+        """
+        try:
+            if not self.initialized:
+                return {
+                    "success": False,
+                    "error": "System not initialized"
+                }
+
+            # Validate file exists
+            if not os.path.exists(file_path):
+                return {
+                    "success": False,
+                    "error": f"File not found: {file_path}"
+                }
+
+            # Validate file type
+            file_extension = Path(filename).suffix.lower()
+            if file_extension not in ['.pdf', '.txt', '.docx']:
+                return {
+                    "success": False,
+                    "error": f"Unsupported file type: {file_extension}. Supported: PDF, TXT, DOCX"
+                }
+
+            # Upload to RAG agent
+            result = await self.rag_agent.add_document(file_path)
+
+            return result
+
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e)
+            }
+
+    async def cleanup(self):
+        """Cleanup resources."""
+        if self.initialized:
+            await self.crypto_agent.cleanup()
+            await self.rag_agent.cleanup()
+            await self.stock_agent.cleanup()
+            await self.search_agent.cleanup()
+            await self.finance_tracker.cleanup()
+            print("🧹 Cleanup complete")
+        self.chat_history.clear()
+
+    def get_agent_status(self) -> Dict[str, bool]:
+        """Get status of all agents."""
+        return {
+            "crypto": self.crypto_agent is not None,
+            "rag": self.rag_agent is not None,
+            "stock": self.stock_agent is not None,
+            "search": self.search_agent is not None,
+            "finance_tracker": self.finance_tracker is not None
+        }
+
+
+# ============================================================================
+# FastAPI Application
+# ============================================================================
+
+app = FastAPI(
+    title="Multi-Agent Assistant API",
+    description="FastAPI interface for multi-agent LLM system with ReAct supervisor",
+    version="1.0.0"
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Adjust in production
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Initialize multi-agent app
+multi_agent_app = MultiAgentApp()
+
+
+# ============================================================================
+# Startup/Shutdown Events
+# ============================================================================
+
+@app.on_event("startup")
+async def startup_event():
+    """Initialize system on startup."""
+    print("=" * 60)
+    print("🚀 Starting FastAPI Multi-Agent Assistant")
+    print("=" * 60)
+
+    # Validate configuration
+    try:
+        from src.core.config import config
+        config.validate()
+        print("✅ Configuration validated")
+    except ValueError as e:
+        print(f"❌ Configuration Error: {e}")
+        raise
+
+    # Initialize all agents
+    await multi_agent_app.initialize()
+    print("=" * 60)
+
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    """Cleanup on shutdown."""
+    print("\n🛑 Shutting down...")
+    await multi_agent_app.cleanup()
+    print("👋 Goodbye!")
+
+
+# ============================================================================
+# API Endpoints
+# ============================================================================
+
+@app.get("/", tags=["Root"])
+async def root():
+    """Root endpoint."""
+    return {
+        "message": "Multi-Agent Assistant API",
+        "version": "1.0.0",
+        "docs": "/docs",
+        "health": "/health"
+    }
+
+
+@app.get("/health", response_model=HealthResponse, tags=["Health"])
+async def health_check():
+    """
+    Health check endpoint.
+
+    Returns system status and agent availability.
+    """
+    return HealthResponse(
+        status="healthy" if multi_agent_app.initialized else "initializing",
+        initialized=multi_agent_app.initialized,
+        agents=multi_agent_app.get_agent_status()
+    )
+
+
+@app.post("/api/v1/chat/stream", tags=["Chat"])
+async def stream_chat(request: ChatRequest):
+    """
+    Stream chat responses with intermediate reasoning steps.
+
+    Uses Server-Sent Events (SSE) to stream updates in real-time.
+
+    Args:
+        request: ChatRequest with message and optional history
+
+    Returns:
+        StreamingResponse with SSE events
+    """
+    # Convert ChatMessage models to internal format
+    internal_history = []
+    for msg in request.history:
+        if msg.role == "user":
+            internal_history.append({"user": msg.content})
+        elif msg.role == "assistant":
+            internal_history.append({"assistant": msg.content})
+
+    async def event_generator():
+        """Generate SSE events with explicit flushing."""
+        try:
+            async for update in multi_agent_app.process_query_streaming(
+                request.message,
+                internal_history
+            ):
+                # Format as SSE with explicit newlines
+                event_data = json.dumps(update)
+                yield f"data: {event_data}\n\n"
+                # Force flush by yielding empty string (triggers send)
+                await asyncio.sleep(0)  # Allow event loop to process
+        except Exception as e:
+            error_event = json.dumps({"type": "error", "error": str(e)})
+            yield f"data: {error_event}\n\n"
+
+    return StreamingResponse(
+        event_generator(),
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            "X-Accel-Buffering": "no",  # Disable nginx buffering
+        }
+    )
+
+
+@app.websocket("/ws/v1/chat")
+async def websocket_chat(websocket: WebSocket):
+    """
+    WebSocket endpoint for chat with streaming updates.
+
+    Client sends: {"message": "query", "history": [...]}
+    Server streams: {"type": "...", "data": {...}}
+    """
+    await websocket.accept()
+
+    try:
+        while True:
+            # Receive message from client
+            data = await websocket.receive_json()
+            message = data.get("message", "")
+            history = data.get("history", [])
+
+            # Convert to internal format
+            internal_history = []
+            for msg in history:
+                if msg.get("role") == "user":
+                    internal_history.append({"user": msg.get("content", "")})
+                elif msg.get("role") == "assistant":
+                    internal_history.append({"assistant": msg.get("content", "")})
+
+            # Stream responses
+            async for update in multi_agent_app.process_query_streaming(message, internal_history):
+                await websocket.send_json(update)
+
+    except WebSocketDisconnect:
+        print("WebSocket client disconnected")
+    except Exception as e:
+        print(f"WebSocket error: {e}")
+        await websocket.close(code=1011, reason=str(e))
+
+
+@app.post("/api/v1/documents/upload", response_model=UploadResponse, tags=["Documents"])
+async def upload_document(file: UploadFile = File(...)):
+    """
+    Upload a document to the RAG agent.
+
+    Supported file types: PDF, TXT, DOCX
+
+    Args:
+        file: Uploaded file
+
+    Returns:
+        UploadResponse with status and details
+    """
+    # Save uploaded file temporarily
+    with tempfile.NamedTemporaryFile(delete=False, suffix=Path(file.filename).suffix) as tmp_file:
+        content = await file.read()
+        tmp_file.write(content)
+        tmp_file_path = tmp_file.name
+
+    try:
+        # Process upload
+        result = await multi_agent_app.upload_document(tmp_file_path, file.filename)
+
+        if result.get("success"):
+            return UploadResponse(
+                success=True,
+                message="Document uploaded successfully",
+                details={
+                    "filename": result.get("filename"),
+                    "file_type": result.get("file_type"),
+                    "chunks_added": result.get("chunks_added"),
+                    "total_documents": result.get("total_documents")
+                }
+            )
+        else:
+            raise HTTPException(
+                status_code=400,
+                detail=result.get("error", "Upload failed")
+            )
+
+    finally:
+        # Clean up temp file
+        if os.path.exists(tmp_file_path):
+            os.unlink(tmp_file_path)
+
+
+# ============================================================================
+# Main Entry Point
+# ============================================================================
+
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run(
+        "api:app",
+        host="0.0.0.0",
+        port=8000,
+        reload=True,
+        log_level="info"
+    )

src/core/config.py

@@ -0,0 +1,121 @@
+"""Configuration for multi-agent RAG system."""
+import os
+from typing import Optional
+from dataclasses import dataclass
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+
+@dataclass
+class Config:
+    """Application configuration."""
+
+    # API Keys
+    GOOGLE_API_KEY: Optional[str] = None
+    COINGECKO_API_KEY: Optional[str] = None
+    ALPHA_VANTAGE_API_KEY: Optional[str] = None
+    # ChromaDB Cloud Configuration
+    CHROMA_API_KEY: Optional[str] = None
+    CHROMA_TENANT: Optional[str] = None
+    CHROMA_DATABASE: Optional[str] = None
+    CHROMA_CLOUD_HOST: str = "api.trychroma.com"
+
+    # ChromaDB Collection Names
+    DOCUMENTS_COLLECTION: str = "test-embed"
+
+    # Embedding Configuration
+    EMBEDDING_FUNCTION: str = "default"  # Options: default, openai, cohere, jina, voyageai
+
+    # Google Cloud SQL Configuration
+    CLOUD_SQL_INSTANCE_CONNECTION_NAME: Optional[str] = None  # Format: project:region:instance
+    CLOUD_SQL_DB_USER: Optional[str] = None
+    CLOUD_SQL_DB_PASS: Optional[str] = None
+    CLOUD_SQL_DB_NAME: Optional[str] = None
+    CLOUD_SQL_PRIVATE_IP: bool = False  # Set to True to use private IP
+
+    # MCP Toolbox Configuration (for Finance Tracker Agent)
+    GCP_PROJECT_ID: Optional[str] = None  # Google Cloud Project ID
+    CLOUD_SQL_REGION: Optional[str] = None  # e.g., us-central1
+    CLOUD_SQL_INSTANCE: Optional[str] = None  # Instance name only (not full connection string)
+    MCP_TOOLBOX_SERVER_URL: str = "http://localhost:5000"  # MCP Toolbox HTTP server URL
+
+    # CoinGecko MCP Server Configuration
+    COINGECKO_MCP_URL: str = "https://mcp.pro-api.coingecko.com/mcp"
+    COINGECKO_MCP_AUTH_URL: str = "https://mcp.pro-api.coingecko.com/auth"
+
+    # UI Configuration
+    UI_PORT: int = 7860
+    UI_HOST: str = "0.0.0.0"
+    MAX_FILE_SIZE_MB: int = 50
+    ALLOWED_FILE_TYPES: list = None
+
+    def __post_init__(self):
+        """Initialize mutable default values."""
+        if self.ALLOWED_FILE_TYPES is None:
+            self.ALLOWED_FILE_TYPES = [".pdf", ".txt", ".docx"]
+    
+    @classmethod
+    def from_env(cls) -> "Config":
+        """Load configuration from environment variables."""
+        return cls(
+            ALPHA_VANTAGE_API_KEY=os.getenv("ALPHA_VANTAGE_API_KEY"),
+            GOOGLE_API_KEY=os.getenv("GOOGLE_API_KEY"),
+            COINGECKO_API_KEY=os.getenv("COINGECKO_API_KEY"),
+            COINGECKO_MCP_URL=os.getenv(
+                "COINGECKO_MCP_URL",
+                "https://mcp.pro-api.coingecko.com/mcp"
+            ),
+            COINGECKO_MCP_AUTH_URL=os.getenv(
+                "COINGECKO_MCP_AUTH_URL",
+                "https://mcp.pro-api.coingecko.com/auth"
+            ),
+            CHROMA_API_KEY=os.getenv("CHROMA_API_KEY"),
+            CHROMA_TENANT=os.getenv("CHROMA_TENANT"),
+            CHROMA_DATABASE=os.getenv("CHROMA_DATABASE"),
+            CHROMA_CLOUD_HOST=os.getenv("CHROMA_CLOUD_HOST", "api.trychroma.com"),
+            EMBEDDING_FUNCTION=os.getenv("CHROMA_EMBEDDING_FUNCTION", "default"),
+            DOCUMENTS_COLLECTION=os.getenv("DOCUMENTS_COLLECTION", "mcp-test"),
+            MAX_FILE_SIZE_MB=int(os.getenv("MAX_FILE_SIZE_MB", "50")),
+            CLOUD_SQL_INSTANCE_CONNECTION_NAME=os.getenv("CLOUD_SQL_INSTANCE_CONNECTION_NAME"),
+            CLOUD_SQL_DB_USER=os.getenv("CLOUD_SQL_DB_USER"),
+            CLOUD_SQL_DB_PASS=os.getenv("CLOUD_SQL_DB_PASS"),
+            CLOUD_SQL_DB_NAME=os.getenv("CLOUD_SQL_DB_NAME", "finance_tracker"),
+            CLOUD_SQL_PRIVATE_IP=os.getenv("CLOUD_SQL_PRIVATE_IP", "False").lower() == "true",
+            GCP_PROJECT_ID=os.getenv("GCP_PROJECT_ID"),
+            CLOUD_SQL_REGION=os.getenv("CLOUD_SQL_REGION"),
+            CLOUD_SQL_INSTANCE=os.getenv("CLOUD_SQL_INSTANCE"),
+            MCP_TOOLBOX_SERVER_URL=os.getenv("MCP_TOOLBOX_SERVER_URL", "http://localhost:5000"),
+        )
+    
+    def validate(self) -> None:
+        """Validate required configuration."""
+        errors = []
+
+        if not self.GOOGLE_API_KEY:
+            errors.append("GOOGLE_API_KEY environment variable is required")
+
+        if not self.CHROMA_API_KEY:
+            errors.append("CHROMA_API_KEY environment variable is required for ChromaDB Cloud")
+
+        if not self.CHROMA_TENANT:
+            errors.append("CHROMA_TENANT environment variable is required for ChromaDB Cloud")
+
+        if not self.CHROMA_DATABASE:
+            errors.append("CHROMA_DATABASE environment variable is required for ChromaDB Cloud")
+
+        if not self.ALPHA_VANTAGE_API_KEY:
+                raise ValueError(
+                    "ALPHA_VANTAGE_API_KEY not configured. "
+                    "Add it to your .env file. "
+                    "Get your API key from: https://www.alphavantage.co/support/#api-key"
+                )
+        if errors:
+            raise ValueError(
+                "Configuration validation failed:\n" + "\n".join(f"  - {e}" for e in errors)
+            )
+
+
+# Global config instance
+config = Config.from_env()

src/core/langgraph_supervisor.py

@@ -0,0 +1,616 @@
+from typing import Any, Dict, List, Optional, TypedDict, Annotated, Sequence, AsyncGenerator
+import operator
+
+import asyncio
+from asyncio import Queue
+
+from langgraph.graph import StateGraph, END
+from langchain_core.messages import BaseMessage, HumanMessage, AIMessage, SystemMessage
+from langchain_google_genai import ChatGoogleGenerativeAI
+
+
+from src.core.config import config
+
+
+class AgentState(TypedDict):
+    """State for the ReAct agent pattern."""
+    messages: Annotated[Sequence[BaseMessage], operator.add]
+    query: str
+    agent_outputs: Dict[str, Any]
+    reasoning_steps: List[str]
+    final_answer: Optional[str]
+    current_step: int
+    max_steps: int
+
+
+class ReActSupervisor:
+    """Supervisor using ReAct pattern for multi-agent orchestration with streaming."""
+    
+    def __init__(
+        self,
+        crypto_agent=None,
+        rag_agent=None,
+        stock_agent=None,
+        search_agent=None,
+        finance_tracker=None,
+        max_steps: int = 5
+    ):
+        """
+        Initialize the ReAct supervisor.
+
+        Args:
+            crypto_agent: Crypto agent instance
+            rag_agent: RAG agent instance
+            stock_agent: Stock agent instance
+            search_agent: Web search agent instance (DuckDuckGo)
+            finance_tracker: Finance tracker agent instance
+            max_steps: Maximum reasoning steps before forcing completion
+        """
+        self.crypto_agent = crypto_agent
+        self.rag_agent = rag_agent
+        self.stock_agent = stock_agent
+        self.search_agent = search_agent
+        self.finance_tracker = finance_tracker
+        self.max_steps = max_steps
+        self.streaming_callback = None  # For streaming updates
+        
+        # Initialize supervisor LLM with structured output
+        self.supervisor_llm = ChatGoogleGenerativeAI(
+            model="gemini-2.5-flash",
+            temperature=0.1,
+            google_api_key=config.GOOGLE_API_KEY,
+        )
+        
+        # Build the ReAct workflow
+        self.graph = self._build_react_graph()
+        self.compiled_graph = self.graph.compile()
+    
+    def _build_react_graph(self) -> StateGraph:
+        """Build the ReAct pattern graph."""
+        
+        # Create the state graph
+        workflow = StateGraph(AgentState)
+        
+        # Add nodes
+        workflow.add_node("think", self.think_node)
+        workflow.add_node("act_crypto", self.act_crypto_node)
+        workflow.add_node("act_rag", self.act_rag_node)
+        workflow.add_node("act_stock", self.act_stock_node)
+        workflow.add_node("act_search", self.act_search_node)
+        workflow.add_node("act_finance_tracker", self.act_finance_tracker_node)
+        workflow.add_node("observe", self.observe_node)
+        workflow.add_node("finish", self.finish_node)
+        
+        # Set entry point
+        workflow.set_entry_point("think")
+        
+        # Add routing from think node
+        workflow.add_conditional_edges(
+            "think",
+            self.route_from_thinking,
+            {
+                "crypto": "act_crypto",
+                "rag": "act_rag",
+                "stock": "act_stock",
+                "search": "act_search",
+                "finance_tracker": "act_finance_tracker",
+                "finish": "finish",
+            }
+        )
+
+        # Actions lead to observe
+        workflow.add_edge("act_crypto", "observe")
+        workflow.add_edge("act_rag", "observe")
+        workflow.add_edge("act_stock", "observe")
+        workflow.add_edge("act_search", "observe")
+        workflow.add_edge("act_finance_tracker", "observe")
+        
+        # Observe leads back to think (or finish if max steps)
+        workflow.add_conditional_edges(
+            "observe",
+            self.should_continue,
+            {
+                "continue": "think",
+                "finish": "finish"
+            }
+        )
+        
+        # Finish ends the graph
+        workflow.add_edge("finish", END)
+        
+        return workflow
+    
+    async def _emit_update(self, update: Dict[str, Any]):
+        """Emit streaming update if callback is set."""
+        if self.streaming_callback:
+            await self.streaming_callback(update)
+    
+    async def think_node(self, state: AgentState) -> Dict[str, Any]:
+        """Reasoning step: Analyze current state and decide next action."""
+        current_step = state.get("current_step", 0) + 1
+        
+        # Build context from previous outputs
+        context = self._build_context(state)
+        
+        # Create reasoning prompt
+        think_prompt = f"""You are a ReAct supervisor orchestrating multiple agents to answer user queries.
+
+Current Query: {state['query']}
+
+Available Actions:
+- CALL_CRYPTO: Get cryptocurrency market data, prices, trends
+- CALL_STOCK: Get stock market data, company information, financial data
+- CALL_FINANCE_TRACKER: Manage personal stock portfolio (add transactions, view positions, analyze performance, get portfolio news)
+- CALL_RAG: Search and retrieve information from uploaded documents
+- CALL_SEARCH: Search the web for current information, news, or general knowledge
+- FINISH: Provide final answer (use when you have sufficient information)
+
+Current Step: {current_step}/{self.max_steps}
+
+Information Gathered So Far:
+{context}
+
+IMPORTANT INSTRUCTIONS:
+1. Check what information you ALREADY HAVE in the context above
+2. Do NOT call the same agent twice unless you need different information
+3. If you already have an answer from any agent, move to FINISH
+4. Only call another agent if you need ADDITIONAL different information
+5. Use CALL_SEARCH for general knowledge, current events, and news
+6. FINISH when you have enough information to answer the user's query
+
+Based on what you know so far, reason about what to do next.
+Format your response as:
+
+THOUGHT: [Analyze what you have and what you still need]
+ACTION: [CALL_CRYPTO | CALL_STOCK | CALL_RAG | CALL_SEARCH | FINISH]
+JUSTIFICATION: [Why this action will help]"""
+
+        response = await self.supervisor_llm.ainvoke([
+            SystemMessage(content="You are a ReAct supervisor. Think step by step and avoid redundant actions."),
+            HumanMessage(content=think_prompt)
+        ])
+        
+        # Parse the response
+        content = response.content
+        thought = ""
+        action = "finish"
+        justification = ""
+        
+        if "THOUGHT:" in content:
+            thought = content.split("THOUGHT:")[1].split("ACTION:")[0].strip()
+        
+        if "ACTION:" in content:
+            action_text = content.split("ACTION:")[1].split("\n")[0].strip().upper()
+            if "CRYPTO" in action_text:
+                action = "crypto"
+            elif "FINANCE_TRACKER" in action_text or "FINANCE" in action_text:
+                action = "finance_tracker"
+            elif "STOCK" in action_text:
+                action = "stock"
+            elif "RAG" in action_text:
+                action = "rag"
+            elif "SEARCH" in action_text:
+                action = "search"
+            else:
+                action = "finish"
+        
+        if "JUSTIFICATION:" in content:
+            justification = content.split("JUSTIFICATION:")[1].strip()
+        
+        # Add reasoning step
+        reasoning_steps = state.get("reasoning_steps", [])
+        reasoning_steps.append(f"Step {current_step}: {thought} -> Action: {action}")
+        
+        print(f"\nThinking (Step {current_step}):")
+        print(f"   Thought: {thought}")
+        print(f"   Action: {action}")
+        print(f"   Justification: {justification}")
+        
+        # Emit streaming update
+        await self._emit_update({
+            "type": "thinking",
+            "step": current_step,
+            "thought": thought,
+            "action": action,
+            "justification": justification
+        })
+        
+        return {
+            "current_step": current_step,
+            "reasoning_steps": reasoning_steps,
+            "messages": [AIMessage(content=f"Thought: {thought}\nAction: {action}")],
+            "next_action": action
+        }
+    
+    async def act_crypto_node(self, state: AgentState) -> Dict[str, Any]:
+        """Execute crypto agent and return raw output."""
+        if not self.crypto_agent:
+            return {"agent_outputs": {"crypto_error": "Crypto agent not available"}}
+        
+        print("   Calling Crypto Agent...")
+        await self._emit_update({"type": "action", "agent": "crypto"})
+        
+        result = await self.crypto_agent.process(
+            state["query"],
+            history=self._extract_history(state["messages"])
+        )
+        
+        agent_outputs = state.get("agent_outputs", {})
+        agent_outputs["crypto"] = result
+        
+        return {"agent_outputs": agent_outputs}
+    
+    async def act_rag_node(self, state: AgentState) -> Dict[str, Any]:
+        """Execute RAG agent and return raw output."""
+        if not self.rag_agent:
+            return {"agent_outputs": {"rag_error": "RAG agent not available"}}
+        
+        print("   Calling RAG Agent...")
+        await self._emit_update({"type": "action", "agent": "rag"})
+        
+        result = await self.rag_agent.process(
+            state["query"],
+            history=self._extract_history(state["messages"])
+        )
+        
+        agent_outputs = state.get("agent_outputs", {})
+        agent_outputs["rag"] = result
+        
+        return {"agent_outputs": agent_outputs}
+    
+    async def act_stock_node(self, state: AgentState) -> Dict[str, Any]:
+        """Execute stock agent and return raw output."""
+        if not self.stock_agent:
+            return {"agent_outputs": {"stock_error": "Stock agent not available"}}
+        
+        print("   Calling Stock Agent...")
+        await self._emit_update({"type": "action", "agent": "stock"})
+        
+        result = await self.stock_agent.process(
+            state["query"],
+            history=self._extract_history(state["messages"])
+        )
+        
+        agent_outputs = state.get("agent_outputs", {})
+        agent_outputs["stock"] = result
+        
+        return {"agent_outputs": agent_outputs}
+    
+    async def act_search_node(self, state: AgentState) -> Dict[str, Any]:
+        """Execute web search agent and return raw output."""
+        if not self.search_agent:
+            return {"agent_outputs": {"search_error": "Search agent not available"}}
+
+        print("   Calling Web Search Agent...")
+        await self._emit_update({"type": "action", "agent": "search"})
+
+        result = await self.search_agent.process(
+            state["query"],
+            history=self._extract_history(state["messages"])
+        )
+
+        agent_outputs = state.get("agent_outputs", {})
+        agent_outputs["search"] = result
+
+        return {"agent_outputs": agent_outputs}
+
+    async def act_finance_tracker_node(self, state: AgentState) -> Dict[str, Any]:
+        """Execute finance tracker agent and return raw output."""
+        if not self.finance_tracker:
+            return {"agent_outputs": {"finance_tracker_error": "Finance Tracker agent not available"}}
+
+        print("   Calling Finance Tracker Agent...")
+        await self._emit_update({"type": "action", "agent": "finance_tracker"})
+
+        result = await self.finance_tracker.process(
+            state["query"],
+            history=self._extract_history(state["messages"])
+        )
+
+        agent_outputs = state.get("agent_outputs", {})
+        agent_outputs["finance_tracker"] = result
+
+        return {"agent_outputs": agent_outputs}
+
+    async def observe_node(self, state: AgentState) -> Dict[str, Any]:
+        """Process and observe the latest agent output."""
+        agent_outputs = state.get("agent_outputs", {})
+
+        latest_output = "No new observations"
+        latest_agent = "unknown"
+        search_urls = None
+        tool_calls = None
+
+        if agent_outputs:
+            for agent_name, output in list(agent_outputs.items())[-1:]:
+                if isinstance(output, dict) and output.get("success"):
+                    response = output.get('response', 'No response')
+                    latest_output = response
+                    latest_agent = agent_name
+                    # Extract search URLs if available (from search agent)
+                    if "search_urls" in output:
+                        search_urls = output["search_urls"]
+                    # Extract tool calls if available (from MCP agents)
+                    if "tool_calls" in output:
+                        tool_calls = output["tool_calls"]
+                    break
+
+        # Prepend tool calls to the summary if available
+        summary = latest_output
+        if tool_calls:
+            tool_calls_text = "\n".join(tool_calls)
+            summary = f"{tool_calls_text}\n   Observation from {latest_agent}: {latest_output}"
+
+        # Apply length limit
+        summary = summary[:2000] + "..." if len(summary) > 2000 else summary
+        print(f"   Observation from {latest_agent}: {summary}")
+
+        # Emit streaming update with search URLs if available
+        update_data = {
+            "type": "observation",
+            "agent": latest_agent,
+            "summary": summary
+        }
+        if search_urls:
+            update_data["search_urls"] = search_urls
+
+        await self._emit_update(update_data)
+
+        return {
+            "messages": [AIMessage(content=f"Observation from {latest_agent}:\n{latest_output}")]
+        }
+    
+    async def finish_node(self, state: AgentState) -> Dict[str, Any]:
+        """Synthesize all agent outputs and generate final answer with streaming."""
+        agent_outputs = state.get("agent_outputs", {})
+        reasoning_steps = state.get("reasoning_steps", [])
+
+        print("\nSupervisor Synthesizing Final Answer...")
+
+        # Build synthesis prompt with conversation history
+        synthesis_prompt = f"""You are synthesizing information to answer this query: {state['query']}
+
+"""
+
+        # Include conversation history for context
+        messages = state.get("messages", [])
+        if messages:
+            synthesis_prompt += "CONVERSATION HISTORY:\n"
+            for msg in messages:
+                if isinstance(msg, HumanMessage):
+                    synthesis_prompt += f"User: {msg.content}\n"
+                elif isinstance(msg, AIMessage):
+                    synthesis_prompt += f"Assistant: {msg.content}\n"
+            synthesis_prompt += "\n"
+
+        synthesis_prompt += f"""Your reasoning process:
+{chr(10).join(reasoning_steps)}
+
+Information gathered from agents:"""
+
+        for agent_name, output in agent_outputs.items():
+            if isinstance(output, dict) and output.get("success"):
+                synthesis_prompt += f"\n\n{agent_name.upper()} Agent Response:\n{output.get('response', 'No response')}"
+
+        synthesis_prompt += """
+
+Now provide a comprehensive, well-structured answer that:
+1. Directly addresses the user's query (considering the conversation history if present)
+2. Integrates insights from all relevant agent outputs
+3. Is clear and actionable
+4. Highlights any important findings or recommendations
+5. Cites sources when appropriate
+
+Final Answer:"""
+
+        # Emit start of final answer
+        await self._emit_update({
+            "type": "final_start"
+        })
+
+        # Stream the final answer token by token
+        # Stream the final answer token by token
+        final_answer = ""
+        async for chunk in self.supervisor_llm.astream([
+            SystemMessage(content="You are providing the final, synthesized answer."),
+            HumanMessage(content=synthesis_prompt)
+        ]):
+            if hasattr(chunk, 'content') and chunk.content:
+                # Clean unicode artifacts from Gemini streaming
+                clean_content = chunk.content.replace('∗', '*')
+                final_answer += clean_content
+                # Emit each token/chunk as it arrives
+                await self._emit_update({
+                    "type": "final_token",
+                    "token": clean_content,
+                    "accumulated": final_answer
+                })
+
+        # Emit completion of final answer
+        await self._emit_update({
+            "type": "final_complete",
+            "response": final_answer
+        })
+
+        return {
+            "final_answer": final_answer,
+            "messages": [AIMessage(content=final_answer)]
+        }
+    
+    def route_from_thinking(self, state: AgentState) -> str:
+        """Route based on thinking decision."""
+        last_message = state["messages"][-1] if state["messages"] else None
+        
+        if last_message and "Action:" in last_message.content:
+            try:
+                action_line = last_message.content.split("Action:")[1].split("\n")[0].strip().upper()
+                
+                if "CRYPTO" in action_line or "CALL_CRYPTO" in action_line:
+                    return "crypto"
+                elif "FINANCE_TRACKER" in action_line or "CALL_FINANCE_TRACKER" in action_line or "FINANCE" in action_line:
+                    return "finance_tracker"
+                elif "STOCK" in action_line or "CALL_STOCK" in action_line:
+                    return "stock"
+                elif "RAG" in action_line or "CALL_RAG" in action_line:
+                    return "rag"
+                elif "SEARCH" in action_line or "CALL_SEARCH" in action_line:
+                    return "search"
+                elif "FINISH" in action_line:
+                    return "finish"
+            except (IndexError, AttributeError):
+                pass
+        
+        return "finish"
+    
+    def should_continue(self, state: AgentState) -> str:
+        """Decide whether to continue reasoning or finish."""
+        current_step = state.get("current_step", 0)
+        
+        if current_step >= self.max_steps:
+            print(f"   Max steps ({self.max_steps}) reached, finishing...")
+            return "finish"
+        
+        return "continue"
+    
+    def _build_context(self, state: AgentState) -> str:
+        """Build context string from current state, including conversation history."""
+        context_parts = []
+
+        # Include conversation history for context
+        messages = state.get("messages", [])
+        if messages:
+            history_text = "=== CONVERSATION HISTORY ===\n"
+            for msg in messages:
+                if isinstance(msg, HumanMessage):
+                    history_text += f"User: {msg.content}\n"
+                elif isinstance(msg, AIMessage):
+                    history_text += f"Assistant: {msg.content}\n"
+            context_parts.append(history_text)
+
+        # Include agent outputs from current query
+        agent_outputs = state.get("agent_outputs", {})
+        if agent_outputs:
+            for agent_name, output in agent_outputs.items():
+                if isinstance(output, dict) and output.get("success"):
+                    response = output.get("response", "No response")
+                    # Increased limit to provide more context to LLM
+                    if len(response) > 5000:
+                        response = response[:5000] + f"... [Response continues for {len(response)} total chars]"
+                    context_parts.append(f"=== {agent_name.upper()} Agent ===\n{response}")
+
+        return "\n\n".join(context_parts) if context_parts else "No information gathered yet."
+    
+    def _extract_history(self, messages: Sequence[BaseMessage]) -> List[Dict[str, str]]:
+        """Extract chat history from messages."""
+        history = []
+        for msg in messages:
+            if isinstance(msg, HumanMessage):
+                history.append({"user": msg.content})
+            elif isinstance(msg, AIMessage):
+                history.append({"assistant": msg.content})
+        return history[-10:]
+    
+    async def process(self, query: str, history: Optional[List[Dict[str, str]]] = None) -> Dict[str, Any]:
+        """Process query through ReAct supervisor pattern."""
+        initial_state: AgentState = {
+            "messages": [],
+            "query": query,
+            "agent_outputs": {},
+            "reasoning_steps": [],
+            "final_answer": None,
+            "current_step": 0,
+            "max_steps": self.max_steps
+        }
+        
+        if history:
+            for turn in history[-3:]:
+                if "user" in turn:
+                    initial_state["messages"].append(HumanMessage(content=turn["user"]))
+                if "assistant" in turn:
+                    initial_state["messages"].append(AIMessage(content=turn["assistant"]))
+        
+        try:
+            print(f"\nReAct Supervisor starting for query: '{query}'")
+            print(f"   Max steps: {self.max_steps}")
+            
+            final_state = await self.compiled_graph.ainvoke(initial_state)
+            
+            return {
+                "success": True,
+                "response": final_state.get("final_answer", "No answer generated"),
+                "reasoning_steps": final_state.get("reasoning_steps", []),
+                "agent_outputs": final_state.get("agent_outputs", {}),
+                "steps_taken": final_state.get("current_step", 0)
+            }
+            
+        except Exception as e:
+            print(f"   ReAct Supervisor error: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "response": f"Supervisor error: {str(e)}"
+            }
+    
+    async def process_streaming(
+        self,
+        query: str,
+        history: Optional[List[Dict[str, str]]] = None
+    ) -> AsyncGenerator[Dict[str, Any], None]:
+        """
+        Process query with true async streaming using Queue.
+        
+        Yields update dictionaries with types: thinking, action, observation, final, error
+        """
+        updates_queue = Queue()
+        
+        async def callback(update: Dict[str, Any]):
+            """Non-blocking callback to queue updates."""
+            await updates_queue.put(update)
+        
+        # Set streaming callback
+        self.streaming_callback = callback
+        
+        # Start processing in background
+        result_task = asyncio.create_task(self.process(query, history))
+        
+        # Stream updates efficiently without polling
+        try:
+            while not result_task.done():
+                try:
+                    # Non-blocking wait with short timeout
+                    update = await asyncio.wait_for(
+                        updates_queue.get(), 
+                        timeout=0.01  # Very short timeout for responsiveness
+                    )
+                    yield update
+                except asyncio.TimeoutError:
+                    # No update available yet, continue loop
+                    continue
+                except Exception as e:
+                    print(f"Warning: Error getting update from queue: {e}")
+                    continue
+            
+            # Drain any remaining updates from the queue
+            while not updates_queue.empty():
+                try:
+                    update = await updates_queue.get()
+                    yield update
+                except Exception as e:
+                    print(f"Warning: Error draining queue: {e}")
+                    break
+            
+            # Handle final result
+            result = await result_task
+            if not result.get("success"):
+                yield {
+                    "type": "error",
+                    "error": result.get("error", "Unknown error")
+                }
+        
+        except Exception as e:
+            yield {
+                "type": "error",
+                "error": str(e)
+            }
+        finally:
+            self.streaming_callback = None

src/core/mcp_client.py

@@ -0,0 +1,290 @@
+"""Proper MCP client using official Python SDK for MCP servers."""
+import asyncio
+import os
+import sys
+from copy import deepcopy
+from pathlib import Path
+from typing import Dict, Any, List, Optional
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+from src.core.config import config
+
+
+class ProperMCPClient:
+    """Base class for connecting to MCP servers using official SDK."""
+
+    def __init__(self, name: str, server_command: str, server_args: List[str], env: Optional[Dict[str, str]] = None):
+        """
+        Initialize MCP client.
+
+        Args:
+            name: Name of the MCP server
+            server_command: Command to start the MCP server (e.g., 'npx', 'uvx')
+            server_args: Arguments for the server command
+            env: Optional environment variables
+        """
+        self.name = name
+        self.server_command = server_command
+        self.server_args = server_args
+        self.env = env or {}
+        self.session: Optional[ClientSession] = None
+        self.exit_stack = None
+        self.available_tools: List[Dict[str, Any]] = []
+
+    async def connect(self) -> bool:
+        """
+        Connect to the MCP server using stdio transport.
+
+        Returns:
+            True if connection successful
+        """
+        try:
+            # Prepare environment for subprocess (ensure venv scripts on PATH)
+            env_vars = os.environ.copy()
+            if sys.prefix:
+                scripts_dir = Path(sys.prefix) / ("Scripts" if os.name == "nt" else "bin")
+                if scripts_dir.exists():
+                    current_path = env_vars.get("PATH", "")
+                    env_vars["PATH"] = f"{scripts_dir}{os.pathsep}{current_path}" if current_path else str(scripts_dir)
+
+            if self.env:
+                env_vars.update(self.env)
+
+            # Create server parameters
+            server_params = StdioServerParameters(
+                command=self.server_command,
+                args=self.server_args,
+                env=env_vars
+            )
+
+            # Create stdio client and session
+            from contextlib import AsyncExitStack
+            self.exit_stack = AsyncExitStack()
+
+            # Connect to server via stdio
+            stdio_transport = await self.exit_stack.enter_async_context(
+                stdio_client(server_params)
+            )
+
+            read, write = stdio_transport
+            self.session = await self.exit_stack.enter_async_context(
+                ClientSession(read, write)
+            )
+
+            # Initialize the session
+            await self.session.initialize()
+
+            # List available tools
+            tools_result = await self.session.list_tools()
+            self.available_tools = tools_result.tools if hasattr(tools_result, 'tools') else []
+
+            print(f"  ✅ Connected to {self.name} MCP Server")
+            print(f"  📋 Available tools: {len(self.available_tools)}")
+
+            # Print tool names for debugging
+            for tool in self.available_tools:
+                tool_name = tool.name if hasattr(tool, 'name') else str(tool)
+                print(f"    - {tool_name}")
+
+            return True
+
+        except Exception as e:
+            print(f"  ❌ Failed to connect to {self.name}: {e}")
+            import traceback
+            traceback.print_exc()
+            return False
+
+    async def call_tool(self, tool_name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Call a tool on the MCP server.
+
+        Args:
+            tool_name: Name of the tool to call
+            arguments: Arguments for the tool
+
+        Returns:
+            Tool execution result
+        """
+        if not self.session:
+            raise RuntimeError(f"MCP client not connected. Call connect() first.")
+
+        try:
+            # Call the tool using the session
+            result = await self.session.call_tool(tool_name, arguments)
+
+            # Parse result
+            if hasattr(result, 'content'):
+                # Extract content from MCP response
+                content = []
+                for item in result.content:
+                    if hasattr(item, 'text'):
+                        content.append(item.text)
+                    elif hasattr(item, 'data'):
+                        content.append(item.data)
+
+                return {
+                    "success": True,
+                    "result": content[0] if len(content) == 1 else content
+                }
+
+            return {
+                "success": True,
+                "result": str(result)
+            }
+
+        except Exception as e:
+            return {
+                "success": False,
+                "error": f"Tool execution failed: {str(e)}"
+            }
+
+    def get_tools_for_gemini(self) -> List[Dict[str, Any]]:
+        """
+        Convert MCP tools to Gemini function declarations format.
+
+        Returns:
+            List of function declarations for Gemini
+        """
+        def sanitize_schema(node: Any) -> None:
+            if isinstance(node, dict):
+                node.pop("title", None)
+                any_of = node.pop("anyOf", None)
+                if any_of:
+                    replacement = any_of[0] if isinstance(any_of, list) and any_of else None
+                    if isinstance(replacement, dict):
+                        # merge first option into current node
+                        for key, value in replacement.items():
+                            node.setdefault(key, deepcopy(value))
+                    sanitize_schema(replacement)
+
+                for key, value in list(node.items()):
+                    sanitize_schema(value)
+            elif isinstance(node, list):
+                for item in node:
+                    sanitize_schema(item)
+
+        function_declarations = []
+
+        for tool in self.available_tools:
+            # Extract tool information
+            tool_name = tool.name if hasattr(tool, 'name') else str(tool)
+            tool_description = tool.description if hasattr(tool, 'description') else f"MCP tool: {tool_name}"
+
+            # Extract input schema
+            tool_schema = tool.inputSchema if hasattr(tool, 'inputSchema') else {}
+
+            if tool_schema:
+                if hasattr(tool_schema, "to_dict"):
+                    parameters = tool_schema.to_dict()
+                elif isinstance(tool_schema, dict):
+                    parameters = deepcopy(tool_schema)
+                else:
+                    try:
+                        parameters = deepcopy(tool_schema)
+                    except Exception:
+                        parameters = tool_schema
+            else:
+                parameters = {
+                    "type": "object",
+                    "properties": {}
+                }
+
+            sanitize_schema(parameters)
+
+            # Convert to Gemini format
+            function_decl = {
+                "name": tool_name,
+                "description": tool_description,
+                "parameters": parameters
+            }
+
+            function_declarations.append(function_decl)
+
+        return [{"function_declarations": function_declarations}]
+
+    async def cleanup(self) -> None:
+        """Close the MCP session."""
+        if self.exit_stack:
+            await self.exit_stack.aclose()
+            print(f"  🧹 {self.name} MCP client closed")
+
+
+class ChromaMCPClient(ProperMCPClient):
+    """MCP client for Chroma MCP Server."""
+
+    def __init__(self):
+        """Initialize Chroma MCP client."""
+        # Prepare environment variables for Chroma Cloud
+        env = {
+            "CHROMA_CLIENT_TYPE": "cloud",
+            "CHROMA_TENANT": config.CHROMA_TENANT,
+            "CHROMA_DATABASE": config.CHROMA_DATABASE,
+            "CHROMA_API_KEY": config.CHROMA_API_KEY,
+        }
+
+        # Initialize with uvx command to run chroma-mcp
+        super().__init__(
+            name="Chroma",
+            server_command="uvx",
+            server_args=[
+                "chroma-mcp",
+                "--client-type", "cloud"
+            ],
+            env=env
+        )
+
+
+class CoinGeckoMCPClient(ProperMCPClient):
+    """MCP client for CoinGecko MCP Server."""
+
+    def __init__(self):
+        """Initialize CoinGecko MCP client."""
+        # Prepare environment variables
+        env = {}
+        if config.COINGECKO_API_KEY:
+            env["COINGECKO_PRO_API_KEY"] = config.COINGECKO_API_KEY
+            env["COINGECKO_ENVIRONMENT"] = "pro"
+
+        # Initialize with npx command to run CoinGecko MCP
+        super().__init__(
+            name="CoinGecko",
+            server_command="npx",
+            server_args=[
+                "-y",
+                "@coingecko/coingecko-mcp"
+            ],
+            env=env if env else None
+        )
+
+
+# Alternative: Use public CoinGecko MCP endpoint
+class CoinGeckoPublicMCPClient(ProperMCPClient):
+    """MCP client for CoinGecko Public MCP Server."""
+
+    def __init__(self):
+        """Initialize CoinGecko Public MCP client."""
+        # Use the public endpoint via mcp-remote
+        super().__init__(
+            name="CoinGecko Public",
+            server_command="npx",
+            server_args=[
+                "mcp-remote",
+                "https://mcp.api.coingecko.com/sse"
+            ],
+            env=None
+        )
+
+# Have to provide limits to the DuckDuckGo MCP server process to avoid excessive resource usage
+class DuckDuckGoMCPClient(ProperMCPClient):
+    """MCP client for DuckDuckGo MCP Server."""
+
+    def __init__(self):
+        """Initialize DuckDuckGo MCP client."""
+        super().__init__(
+            name="DuckDuckGo",
+            server_command="uvx",
+            server_args=[
+                "duckduckgo-mcp-server"
+            ],
+            env=None
+        )

src/utils/file_processors.py

@@ -0,0 +1,187 @@
+"""File processing utilities for different document types."""
+from pathlib import Path
+from typing import List, Dict, Any, Optional
+import PyPDF2
+from docx import Document
+
+
+class FileProcessor:
+    """Base class for file processing."""
+
+    @staticmethod
+    def get_processor(file_path: Path):
+        """Get appropriate processor based on file extension."""
+        extension = file_path.suffix.lower()
+
+        if extension == '.pdf':
+            return PDFProcessor()
+        elif extension == '.txt':
+            return TXTProcessor()
+        elif extension == '.docx':
+            return DOCXProcessor()
+        else:
+            raise ValueError(f"Unsupported file type: {extension}")
+
+    def extract_text(self, file_path: Path) -> str:
+        """Extract text from file. Override in subclasses."""
+        raise NotImplementedError
+
+    def chunk_text(self, text: str, chunk_size: int = 500, overlap: int = 50) -> List[str]:
+        """
+        Split text into overlapping chunks.
+
+        Args:
+            text: Text to chunk
+            chunk_size: Target size of each chunk in characters
+            overlap: Number of characters to overlap between chunks
+
+        Returns:
+            List of text chunks
+        """
+        if not text.strip():
+            return []
+
+        chunks = []
+        words = text.split()
+
+        current_chunk = []
+        current_length = 0
+
+        for word in words:
+            word_length = len(word) + 1  # +1 for space
+
+            if current_length + word_length > chunk_size and current_chunk:
+                # Save current chunk
+                chunk_text = " ".join(current_chunk)
+                chunks.append(chunk_text)
+
+                # Start new chunk with overlap
+                # Keep last few words for context
+                overlap_words = []
+                overlap_length = 0
+                for w in reversed(current_chunk):
+                    if overlap_length + len(w) + 1 <= overlap:
+                        overlap_words.insert(0, w)
+                        overlap_length += len(w) + 1
+                    else:
+                        break
+
+                current_chunk = overlap_words
+                current_length = overlap_length
+
+            current_chunk.append(word)
+            current_length += word_length
+
+        # Add remaining words
+        if current_chunk:
+            chunks.append(" ".join(current_chunk))
+
+        return chunks
+
+
+class PDFProcessor(FileProcessor):
+    """Processor for PDF files."""
+
+    def extract_text(self, file_path: Path) -> str:
+        """Extract text from PDF file."""
+        text = []
+
+        try:
+            with open(file_path, 'rb') as file:
+                pdf_reader = PyPDF2.PdfReader(file)
+
+                for page_num, page in enumerate(pdf_reader.pages):
+                    page_text = page.extract_text()
+                    if page_text.strip():
+                        text.append(page_text)
+
+            return "\n\n".join(text)
+
+        except Exception as e:
+            raise ValueError(f"Error extracting PDF text: {e}")
+
+
+class TXTProcessor(FileProcessor):
+    """Processor for plain text files."""
+
+    def extract_text(self, file_path: Path) -> str:
+        """Extract text from TXT file."""
+        try:
+            # Try different encodings
+            encodings = ['utf-8', 'utf-16', 'latin-1', 'cp1252']
+
+            for encoding in encodings:
+                try:
+                    with open(file_path, 'r', encoding=encoding) as file:
+                        return file.read()
+                except UnicodeDecodeError:
+                    continue
+
+            raise ValueError("Could not decode text file with any supported encoding")
+
+        except Exception as e:
+            raise ValueError(f"Error reading TXT file: {e}")
+
+
+class DOCXProcessor(FileProcessor):
+    """Processor for DOCX files."""
+
+    def extract_text(self, file_path: Path) -> str:
+        """Extract text from DOCX file."""
+        try:
+            doc = Document(file_path)
+
+            # Extract text from paragraphs
+            paragraphs = [para.text for para in doc.paragraphs if para.text.strip()]
+
+            # Extract text from tables
+            table_text = []
+            for table in doc.tables:
+                for row in table.rows:
+                    row_text = [cell.text.strip() for cell in row.cells if cell.text.strip()]
+                    if row_text:
+                        table_text.append(" | ".join(row_text))
+
+            # Combine all text
+            all_text = paragraphs + table_text
+            return "\n\n".join(all_text)
+
+        except Exception as e:
+            raise ValueError(f"Error extracting DOCX text: {e}")
+
+
+def process_document(
+    file_path: Path,
+    chunk_size: int = 500,
+    overlap: int = 50
+) -> Dict[str, Any]:
+    """
+    Process a document file and return chunks with metadata.
+
+    Args:
+        file_path: Path to the document file
+        chunk_size: Target size of each chunk
+        overlap: Overlap between chunks
+
+    Returns:
+        Dictionary with chunks and metadata
+    """
+    processor = FileProcessor.get_processor(file_path)
+
+    # Extract text
+    text = processor.extract_text(file_path)
+
+    if not text.strip():
+        raise ValueError("No text content found in document")
+
+    # Chunk text
+    chunks = processor.chunk_text(text, chunk_size, overlap)
+
+    return {
+        "filename": file_path.name,
+        "file_type": file_path.suffix.lower(),
+        "file_size": file_path.stat().st_size,
+        "text_length": len(text),
+        "chunks": chunks,
+        "num_chunks": len(chunks)
+    }

tests/test_unit_cases.py

@@ -0,0 +1,264 @@
+"""
+Test suite for FastAPI Multi-Agent Assistant API.
+
+This module tests the core API endpoints including health checks,
+root endpoint, and system initialization.
+"""
+import pytest
+from fastapi.testclient import TestClient
+from src.api.main import app, multi_agent_app
+
+
+# ============================================================================
+# Test Client Setup
+# ============================================================================
+
+@pytest.fixture
+def client():
+    """Create test client for FastAPI application."""
+    return TestClient(app)
+
+
+# ============================================================================
+# Root Endpoint Tests
+# ============================================================================
+
+def test_root_endpoint(client):
+    """Test that root endpoint returns correct API information."""
+    response = client.get("/")
+
+    assert response.status_code == 200
+    data = response.json()
+
+    # Check response structure
+    assert "message" in data
+    assert "version" in data
+    assert "docs" in data
+    assert "health" in data
+
+    # Check specific values
+    assert data["message"] == "Multi-Agent Assistant API"
+    assert data["version"] == "1.0.0"
+    assert data["docs"] == "/docs"
+    assert data["health"] == "/health"
+
+
+def test_root_endpoint_content_type(client):
+    """Test that root endpoint returns JSON content."""
+    response = client.get("/")
+
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "application/json"
+
+
+# ============================================================================
+# Health Check Tests
+# ============================================================================
+
+def test_health_check_endpoint(client):
+    """Test health check endpoint returns proper structure."""
+    response = client.get("/health")
+
+    assert response.status_code == 200
+    data = response.json()
+
+    # Check response structure
+    assert "status" in data
+    assert "initialized" in data
+    assert "agents" in data
+
+    # Check status values
+    assert data["status"] in ["healthy", "initializing"]
+    assert isinstance(data["initialized"], bool)
+    assert isinstance(data["agents"], dict)
+
+
+def test_health_check_agents_status(client):
+    """Test that health check returns all agent statuses."""
+    response = client.get("/health")
+
+    assert response.status_code == 200
+    data = response.json()
+
+    # Check all agents are present
+    expected_agents = ["crypto", "rag", "stock", "search", "finance_tracker"]
+    for agent in expected_agents:
+        assert agent in data["agents"]
+        assert isinstance(data["agents"][agent], bool)
+
+
+def test_health_check_response_model(client):
+    """Test health check response matches Pydantic model."""
+    response = client.get("/health")
+
+    assert response.status_code == 200
+    data = response.json()
+
+    # Validate against expected model structure
+    assert set(data.keys()) == {"status", "initialized", "agents"}
+
+    # Check types
+    assert isinstance(data["status"], str)
+    assert isinstance(data["initialized"], bool)
+    assert isinstance(data["agents"], dict)
+
+
+# ============================================================================
+# API Documentation Tests
+# ============================================================================
+
+def test_openapi_schema_available(client):
+    """Test that OpenAPI schema is accessible."""
+    response = client.get("/openapi.json")
+
+    assert response.status_code == 200
+    schema = response.json()
+
+    assert "openapi" in schema
+    assert "info" in schema
+    assert schema["info"]["title"] == "Multi-Agent Assistant API"
+    assert schema["info"]["version"] == "1.0.0"
+
+
+def test_docs_endpoint_available(client):
+    """Test that Swagger docs are accessible."""
+    response = client.get("/docs")
+
+    assert response.status_code == 200
+    assert "swagger" in response.text.lower() or "html" in response.headers["content-type"]
+
+
+def test_redoc_endpoint_available(client):
+    """Test that ReDoc documentation is accessible."""
+    response = client.get("/redoc")
+
+    assert response.status_code == 200
+
+
+
+# ============================================================================
+# Error Handling Tests
+# ============================================================================
+
+def test_nonexistent_endpoint(client):
+    """Test that nonexistent endpoints return 404."""
+    response = client.get("/nonexistent")
+
+    assert response.status_code == 404
+
+
+def test_invalid_method_on_root(client):
+    """Test that invalid HTTP methods return 405."""
+    response = client.post("/")
+
+    assert response.status_code == 405
+
+
+# ============================================================================
+# Chat Endpoint Tests (Basic)
+# ============================================================================
+
+def test_chat_stream_endpoint_requires_post(client):
+    """Test that chat stream endpoint only accepts POST."""
+    response = client.get("/api/v1/chat/stream")
+
+    assert response.status_code == 405  # Method Not Allowed
+
+
+def test_chat_stream_endpoint_exists(client):
+    """Test that chat stream endpoint exists."""
+    # Send minimal valid request
+    response = client.post(
+        "/api/v1/chat/stream",
+        json={"message": "test"}
+    )
+
+    # Should return 200 or process the request (not 404)
+    assert response.status_code != 404
+
+
+# ============================================================================
+# Upload Endpoint Tests (Basic)
+# ============================================================================
+
+def test_upload_endpoint_requires_post(client):
+    """Test that upload endpoint only accepts POST."""
+    response = client.get("/api/v1/documents/upload")
+
+    assert response.status_code == 405  # Method Not Allowed
+
+
+def test_upload_endpoint_exists(client):
+    """Test that upload endpoint exists."""
+    # Try to access without file (should fail validation, not 404)
+    response = client.post("/api/v1/documents/upload")
+
+    # Should return 422 (validation error) or other, but not 404
+    assert response.status_code != 404
+
+
+# ============================================================================
+# Integration Tests
+# ============================================================================
+
+@pytest.mark.asyncio
+async def test_system_initialization():
+    """Test that multi-agent system can initialize."""
+    # Reset initialization state
+    multi_agent_app.initialized = False
+
+    # Initialize
+    result = await multi_agent_app.initialize()
+
+    # Check initialization
+    assert multi_agent_app.initialized is True
+    assert multi_agent_app.supervisor is not None
+    assert "initialized" in result.lower() or "ready" in result.lower()
+
+
+def test_agent_status_method():
+    """Test get_agent_status returns correct structure."""
+    status = multi_agent_app.get_agent_status()
+
+    assert isinstance(status, dict)
+    expected_agents = ["crypto", "rag", "stock", "search", "finance_tracker"]
+
+    for agent in expected_agents:
+        assert agent in status
+        assert isinstance(status[agent], bool)
+
+
+# ============================================================================
+# Performance Tests
+# ============================================================================
+
+def test_health_check_response_time(client):
+    """Test that health check responds quickly."""
+    import time
+
+    start = time.time()
+    response = client.get("/health")
+    elapsed = time.time() - start
+
+    assert response.status_code == 200
+    assert elapsed < 1.0  # Should respond in less than 1 second
+
+
+def test_root_endpoint_response_time(client):
+    """Test that root endpoint responds quickly."""
+    import time
+
+    start = time.time()
+    response = client.get("/")
+    elapsed = time.time() - start
+
+    assert response.status_code == 200
+    assert elapsed < 0.5  # Should respond in less than 0.5 seconds
+
+
+# ============================================================================
+# Run Tests
+# ============================================================================
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v", "--tb=short"])

ui/gradio_app.py

@@ -0,0 +1,542 @@
+"""Main application with Gradio Chat UI for multi-agent LLM system."""
+import asyncio
+import gradio as gr
+from gradio import ChatMessage
+from src.agents.crypto_agent_mcp import CryptoAgentMCP
+from src.agents.rag_agent_mcp import RAGAgentMCP
+from src.agents.stock_agent_mcp import StockAgentMCP
+from src.agents.search_agent_mcp import SearchAgentMCP
+from src.agents.finance_tracker_agent_mcp import FinanceTrackerMCP
+from typing import Dict, List, AsyncGenerator
+from pathlib import Path
+import os
+from src.core.langgraph_supervisor import ReActSupervisor
+
+class MultiAgentApp:
+    """Main application orchestrating LLM supervisor and agents."""
+
+    def __init__(self):
+        self.crypto_agent = CryptoAgentMCP()
+        self.rag_agent = RAGAgentMCP()
+        self.stock_agent = StockAgentMCP()
+        self.search_agent = SearchAgentMCP()
+        self.finance_tracker = FinanceTrackerMCP()
+        self.supervisor = None
+        self.chat_history: List[Dict[str, str]] = []
+        self.initialized = False
+
+    async def initialize(self):
+        """Initialize all agents and supervisor."""
+        if not self.initialized:
+            print("🚀 Initializing Multi-Agent System...")
+            
+            # Initialize agents first
+            await self.crypto_agent.initialize()
+            await self.rag_agent.initialize()
+            await self.stock_agent.initialize()
+            await self.search_agent.initialize()
+            await self.finance_tracker.initialize()
+
+            # Initialize supervisor with agent references
+            self.supervisor = ReActSupervisor(
+                crypto_agent=self.crypto_agent,
+                rag_agent=self.rag_agent,
+                stock_agent=self.stock_agent,
+                search_agent=self.search_agent,
+                finance_tracker=self.finance_tracker
+            )
+            
+            self.initialized = True
+            print("✅ System initialized with LangGraph supervisor!")
+            return "✅ All agents initialized and ready!"
+
+    async def process_query_streaming(
+        self,
+        message: str,
+        history: List[Dict[str, str]]
+    ) -> AsyncGenerator[ChatMessage, None]:
+        """
+        Process user query with streaming updates showing intermediate steps.
+
+        Args:
+            message: User's input message
+            history: Chat history in Gradio messages format [{"role": "user/assistant", "content": "..."}]
+
+        Yields:
+            ChatMessage objects with metadata for intermediate steps
+        """
+        if not message.strip():
+            yield ChatMessage(role="assistant", content="Please enter a query.")
+            return
+
+        try:
+            # Check if system is initialized
+            if not self.initialized:
+                yield ChatMessage(role="assistant", content="❌ System not initialized. Please restart the application.")
+                return
+
+            # Convert Gradio messages format to internal format
+            internal_history = []
+            for msg in history:
+                role = msg.get("role", "")
+                content = msg.get("content", "")
+                if role == "user":
+                    internal_history.append({"user": content})
+                elif role == "assistant":
+                    internal_history.append({"assistant": content})
+
+            # Track message IDs and action messages for checkmark updates
+            message_id = 0
+            action_message_ids = {}  # Map agent names to their action message IDs
+            final_answer_message_id = None  # Track final answer message ID
+            final_answer_accumulated = ""  # Accumulate streaming final answer
+
+            async for update in self.supervisor.process_streaming(message, history=internal_history):
+                if update.get("type") == "thinking":
+                    # Collect thinking step
+                    step = update.get("step", 0)
+                    thought = update.get("thought", "")
+                    action = update.get("action", "")
+                    justification = update.get("justification", "")
+
+                    step_content = f"**Thought:** {thought}\n\n"
+                    step_content += f"**Action:** {action.upper()}\n\n"
+                    step_content += f"**Justification:** {justification}"
+
+                    message_id += 1
+                    # Yield intermediate step as ChatMessage with metadata
+                    thinking_msg = ChatMessage(
+                        role="assistant",
+                        content=step_content,
+                        metadata={
+                            "title": f"💭 Step {step}: Reasoning",
+                            "id": message_id,
+                            "status": "done"
+                        }
+                    )
+                    yield thinking_msg
+
+                elif update.get("type") == "action":
+                    # Show agent call as intermediate step with pending status
+                    agent = update.get("agent", "unknown")
+                    action_content = f"Calling **{agent.upper()}** agent to gather information..."
+
+                    message_id += 1
+                    action_msg_id = message_id
+                    action_message_ids[agent] = action_msg_id  # Store ID for later update
+                    
+                    action_msg = ChatMessage(
+                        role="assistant",
+                        content=action_content,
+                        metadata={
+                            "title": f"🔧 Calling {agent.title()} Agent",
+                            "id": action_msg_id,
+                            "status": "pending"
+                        }
+                    )
+                    yield action_msg
+
+                elif update.get("type") == "observation":
+                    # Extract tool calls from summary
+                    agent = update.get("agent", "unknown")
+                    summary = update.get("summary", "")
+                    
+                    # Split summary into tool calls and results
+                    tool_calls = []
+                    results = []
+                    for line in summary.split('\n'):
+                        # Match all tool call prefixes from different agents
+                        if any(prefix in line for prefix in ['🔧 MCP Tool call:', '🔧 DuckDuckGo call:', '🔧 MCP Toolbox call:']):
+                            tool_calls.append(line)
+                        elif line.strip():
+                            results.append(line)
+                    
+                    # Update the action message with tool calls
+                    if agent in action_message_ids:
+                        action_msg_id = action_message_ids[agent]
+                        tool_calls_text = '\n'.join(tool_calls) if tool_calls else ""
+                        updated_content = f"✓ Called **{agent.upper()}** agent\n\n{tool_calls_text}"
+                        
+                        updated_action_msg = ChatMessage(
+                            role="assistant",
+                            content=updated_content,
+                            metadata={
+                                "title": f"🔧 Calling {agent.title()} Agent",
+                                "id": action_msg_id,
+                                "status": "done"  
+                            }
+                        )
+                        yield updated_action_msg
+                    
+                    # Show only the results in observation (without tool calls)
+                    if results:
+                        results_text = '\n'.join(results)
+                        message_id += 1
+                        
+                        # Map agent names to emojis
+                        agent_emojis = {
+                            "finance_tracker": "💼",
+                            "crypto": "🪙",
+                            "search": "🌐",
+                            "stock": "📈",
+                            "rag": "📚"
+                        }
+                        agent_emoji = agent_emojis.get(agent.lower(), "📊")
+                        
+                        obs_msg = ChatMessage(
+                            role="assistant",
+                            content=results_text,
+                            metadata={
+                                "title": f"{agent_emoji} {agent.title()} Agent Results",
+                                "id": message_id,
+                                "status": "done"
+                            }
+                        )
+                        yield obs_msg
+
+                elif update.get("type") == "final_start":
+                    # Start of final answer - create placeholder message
+                    final_answer_accumulated = ""
+                    message_id += 1
+                    final_answer_message_id = message_id
+                    # Yield initial empty final answer message
+                    yield ChatMessage(
+                        role="assistant",
+                        content="",
+                        metadata={"id": final_answer_message_id}
+                    )
+
+                elif update.get("type") == "final_token":
+                    # Stream each token of the final answer - update same message
+                    final_answer_accumulated = update.get("accumulated", "")
+                    # Update the same final answer message
+                    yield ChatMessage(
+                        role="assistant",
+                        content=final_answer_accumulated,
+                        metadata={"id": final_answer_message_id}
+                    )
+
+                elif update.get("type") == "final_complete":
+                    # Final answer is complete
+                    if final_answer_accumulated:
+                        yield ChatMessage(
+                            role="assistant",
+                            content=final_answer_accumulated,
+                            metadata={"id": final_answer_message_id}
+                        )
+
+                elif update.get("type") == "error":
+                    # Show error
+                    error = update.get("error", "Unknown error")
+                    yield ChatMessage(
+                        role="assistant",
+                        content=f"**Error:** {error}"
+                    )
+
+            # Update chat history
+            self.chat_history.append({"user": message})
+            if len(self.chat_history) > 20:
+                self.chat_history = self.chat_history[-20:]
+
+        except Exception as e:
+            error_msg = f"❌ **Error processing query:** {str(e)}"
+            yield ChatMessage(role="assistant", content=error_msg)
+
+    async def upload_document(
+        self,
+        file_obj,
+        progress=gr.Progress()
+    ) -> str:
+        """
+        Handle document upload to ChromaDB Cloud.
+
+        Args:
+            file_obj: Gradio file object
+            progress: Gradio progress tracker
+
+        Returns:
+            Status message
+        """
+        try:
+            if not self.initialized:
+                return "❌ System not initialized. Please restart the application."
+
+            if file_obj is None:
+                return "❌ No file selected"
+
+            # Get file path from Gradio file object
+            file_path = file_obj.name if hasattr(file_obj, 'name') else str(file_obj)
+
+            # Validate file exists
+            if not os.path.exists(file_path):
+                return f"❌ File not found: {file_path}"
+
+            # Validate file type
+            file_extension = Path(file_path).suffix.lower()
+            if file_extension not in ['.pdf', '.txt', '.docx']:
+                return f"❌ Unsupported file type: {file_extension}. Supported: PDF, TXT, DOCX"
+
+            # Progress callback
+            def update_progress(percent, message):
+                progress(percent, desc=message)
+
+            # Upload to RAG agent
+            result = await self.rag_agent.add_document(
+                file_path,
+                progress_callback=update_progress
+            )
+
+            if result.get("success"):
+                return (
+                    f"✅ Successfully uploaded {result['filename']}\n"
+                    f"📊 Type: {result['file_type']}\n"
+                    f"📦 Chunks created: {result['chunks_added']}\n"
+                    f"📚 Total documents in collection: {result['total_documents']}"
+                )
+            else:
+                return f"❌ Upload failed: {result.get('error', 'Unknown error')}"
+
+        except Exception as e:
+            return f"❌ Error uploading document: {str(e)}"
+
+    async def cleanup(self):
+        """Cleanup resources."""
+        if self.initialized:
+            await self.crypto_agent.cleanup()
+            await self.rag_agent.cleanup()
+            await self.stock_agent.cleanup()
+            await self.search_agent.cleanup()
+            await self.finance_tracker.cleanup()
+            print("🧹 Cleanup complete")
+        self.chat_history.clear()
+
+app = MultiAgentApp()
+
+try:
+    event_loop = asyncio.get_running_loop()
+except RuntimeError:
+    event_loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(event_loop)
+
+def create_ui():
+    """Create Gradio interface."""
+
+    with gr.Blocks(title="PortfolioMind") as interface:
+        gr.Markdown("""
+        # 🤖 PortfolioMind MCP - The Multi-Agent FinAssistant
+        """)
+        
+        with gr.Row():
+            with gr.Column(scale=3):
+                # Chat Interface
+                chatbot = gr.Chatbot(
+                    label="Multi-Agent Assistant",
+                    height=600,
+                    show_label=True,
+                )
+                
+                with gr.Row():
+                    msg = gr.Textbox(
+                        label="Your Message",
+                        placeholder="Ask about crypto, stocks, documents, or search the web...",
+                        lines=1,
+                        scale=4
+                    )
+                    with gr.Column(scale=1):
+                        submit_btn = gr.Button("Send", variant="primary")
+                        clear_btn = gr.Button("Clear Chat")
+                
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown("""
+                ### 🤖 Available Agents:
+                - 🪙 **Crypto Agent**: Real-time crypto prices, market data, and trends | Uses Coingecko MCP Server
+                - 📊 **Stock Agent**: Stock prices, company info, financial data, and market analysis | Uses Alphavantage MCP Server
+                - 💼 **Finance Tracker**: Manage your personal stock portfolio (add transactions, track performance, get portfolio news)
+                - 📚 **RAG Agent**: Query your uploaded documents with AI | Uses ChromaDB API
+                - 🔍 **Search Agent**: Search the web using DuckDuckGo | Uses DuckDuckGo MCP Server
+                        """)
+                    
+                    with gr.Column(scale=1):
+                        gr.Markdown("""                               
+                ### ❓ Example queries
+                - What's the current price of Bitcoin and Ethereum?
+                - Add 10 shares of AAPL I bought at $150
+                - What's my current portfolio value?
+                - Show me news on my portfolio holdings
+                - What did Jerome Powell say in his latest speech?
+                - Show me Tesla's financial overview
+                - Search for latest AI developments
+                - What does my document say about [topic]?
+                        """)
+                    with gr.Column(scale=1):
+                        gr.Markdown("""                                                                            
+                ### 🤔 How it works
+                1. You ask a question
+                2. The ReAct supervisor analyzes your query and plans a strategy
+                3. It calls relevant agents to gather information
+                4. It synthesizes a comprehensive answer from all sources
+                        """)
+            with gr.Column(scale=1):
+                # Document Upload
+                gr.Markdown("### 📄 Upload Documents")
+                file_upload = gr.File(
+                    label="Upload PDF, TXT, or DOCX",
+                    file_types=[".pdf", ".txt", ".docx"],
+                    type="filepath"
+                )
+                upload_btn = gr.Button("📤 Upload to RAG", variant="secondary")
+                upload_status = gr.Textbox(
+                    label="Upload Status",
+                    lines=4,
+                    interactive=False
+                )
+                
+                # System Status
+                status_box = gr.Textbox(
+                    label="Initialization Status",
+                    value="✅ All agents initialized and ready!" if app.initialized else "⏳ Initializing...",
+                    lines=2,
+                    interactive=False
+                )
+        
+        gr.Markdown("""
+        ---
+        ### 🏗️ System Architecture
+
+        **ReAct Pattern Supervisor** → Analyzes queries and orchestrates agents through reasoning loops
+        
+        **Agent Workflow:**
+        1. **Think**: Supervisor reasons about what information is needed
+        2. **Act**: Calls appropriate agent(s) to gather information
+        3. **Observe**: Reviews agent responses
+        4. **Repeat**: Continues until sufficient information is gathered
+        5. **Synthesize**: Generates comprehensive final answer
+        
+        Each agent uses Gemini LLM with specialized MCP server tools for their domain.
+        """)
+        
+        # Define async wrappers for Gradio
+        async def respond_stream(message, chat_history):
+            """Streaming response handler with intermediate steps."""
+            # Create the full message list once (Gradio pattern: yield same list object)
+            messages = chat_history + [{"role": "user", "content": message}]
+            final_answer_index = None
+            message_id_to_index = {}  # Map message IDs to their index
+
+            async for chat_msg in app.process_query_streaming(message, chat_history):
+                # Check if message has an ID (for updating existing messages)
+                msg_id = None
+                if hasattr(chat_msg, 'metadata') and chat_msg.metadata:
+                    msg_id = chat_msg.metadata.get('id')
+                
+                # Check if this is a final answer message (has ID but minimal metadata)
+                is_final_answer = msg_id and (not chat_msg.metadata.get('title'))
+                
+                if msg_id and msg_id in message_id_to_index:
+                    # Update existing message (e.g., changing status from pending to done)
+                    existing_index = message_id_to_index[msg_id]
+                    messages[existing_index] = chat_msg
+                elif is_final_answer:
+                    if final_answer_index is None:
+                        # First token of final answer - append once
+                        final_answer_index = len(messages)
+                        message_id_to_index[msg_id] = final_answer_index
+                        messages.append(chat_msg)
+                    else:
+                        # Subsequent tokens - replace in place
+                        messages[final_answer_index] = chat_msg
+                else:
+                    # New intermediate step message
+                    if msg_id:
+                        message_id_to_index[msg_id] = len(messages)
+                    messages.append(chat_msg)
+
+                # Yield the SAME messages list (following Gradio streaming pattern)
+                yield messages
+        
+        def upload_document_sync(file_obj, progress=gr.Progress()):
+            """Synchronous wrapper for async document upload."""
+            return event_loop.run_until_complete(app.upload_document(file_obj, progress))
+        
+        def clear_chat():
+            """Clear chat history."""
+            app.chat_history.clear()
+            return []
+        
+        # Connect button actions
+        msg.submit(
+            respond_stream,
+            inputs=[msg, chatbot],
+            outputs=[chatbot]
+        ).then(
+            lambda: "",
+            outputs=[msg]
+        )
+        
+        submit_btn.click(
+            respond_stream,
+            inputs=[msg, chatbot],
+            outputs=[chatbot]
+        ).then(
+            lambda: "",
+            outputs=[msg]
+        )
+        
+        clear_btn.click(
+            clear_chat,
+            outputs=[chatbot]
+        )
+        
+        upload_btn.click(
+            upload_document_sync,
+            inputs=[file_upload],
+            outputs=[upload_status]
+        )
+
+    return interface
+
+
+def main():
+    """Main entry point."""
+    print("=" * 60)
+    print("🚀 Starting Multi-Agent Assistant")
+    print("=" * 60)
+
+    # Validate configuration
+    try:
+        from src.core.config import config
+        config.validate()
+        print("✅ Configuration validated")
+    except ValueError as e:
+        print(f"❌ Configuration Error: {e}")
+        return
+
+    # Initialize all agents at startup
+    print("\n⚡ Initializing all agents at startup...")
+    event_loop.run_until_complete(app.initialize())
+
+    interface = create_ui()
+
+    print("\n📱 Launching Gradio interface...")
+    print("🌐 Access the app at: http://localhost:7860")
+    print("\nPress Ctrl+C to stop the server")
+    print("=" * 60)
+
+    try:
+        interface.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=True,
+            theme=gr.themes.Citrus()
+        )
+    except KeyboardInterrupt:
+        print("\n\n🛑 Shutting down...")
+        # Cleanup
+        event_loop.run_until_complete(app.cleanup())
+        event_loop.close()
+        print("👋 Goodbye!")
+
+
+if __name__ == "__main__":
+    main()

ui/streamlit_app.py

@@ -0,0 +1,473 @@
+
+"""Streamlit UI for Multi-Agent Assistant connecting to FastAPI backend."""
+import streamlit as st
+import requests
+import json
+import os
+from typing import Dict, List, Optional
+import time
+from pathlib import Path
+
+# ============================================================================
+# Configuration
+# ============================================================================
+
+# FastAPI backend URL
+API_BASE_URL = os.getenv("API_BASE_URL", "http://localhost:8000")
+
+# Page configuration
+st.set_page_config(
+    page_title="Multi-Agent Assistant",
+    page_icon="🤖",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# ============================================================================
+# API Client Functions
+# ============================================================================
+
+def check_api_health() -> Dict:
+    """Check if FastAPI backend is available."""
+    try:
+        response = requests.get(f"{API_BASE_URL}/health", timeout=5)
+        response.raise_for_status()
+        return response.json()
+    except Exception as e:
+        return {"status": "offline", "error": str(e)}
+
+
+def stream_chat_response(message: str, history: List[Dict]) -> Dict:
+    """
+    Stream chat response from FastAPI using Server-Sent Events.
+
+    Yields update dictionaries as they arrive.
+    """
+    payload = {
+        "message": message,
+        "history": history
+    }
+
+    try:
+        response = requests.post(
+            f"{API_BASE_URL}/api/v1/chat/stream",
+            json=payload,
+            headers={
+                "Accept": "text/event-stream",
+                "Cache-Control": "no-cache",
+            },
+            stream=True,
+            timeout=120
+        )
+        response.raise_for_status()
+
+        # Use iter_lines with smaller chunk size for faster streaming
+        for line in response.iter_lines(chunk_size=1, decode_unicode=True):
+            if line:
+                if line.startswith('data: '):
+                    data_str = line[6:]  # Remove 'data: ' prefix
+                    try:
+                        event = json.loads(data_str)
+                        yield event
+                    except json.JSONDecodeError:
+                        continue
+    except Exception as e:
+        yield {"type": "error", "error": str(e)}
+
+
+def upload_document(file) -> Dict:
+    """Upload document to FastAPI backend."""
+    try:
+        files = {'file': (file.name, file, file.type)}
+        response = requests.post(
+            f"{API_BASE_URL}/api/v1/documents/upload",
+            files=files,
+            timeout=60
+        )
+        response.raise_for_status()
+        return response.json()
+    except Exception as e:
+        return {"success": False, "message": str(e)}
+
+
+# ============================================================================
+# Session State Initialization
+# ============================================================================
+
+if "messages" not in st.session_state:
+    st.session_state.messages = []
+
+if "chat_history" not in st.session_state:
+    st.session_state.chat_history = []
+
+if "show_intermediate_steps" not in st.session_state:
+    st.session_state.show_intermediate_steps = True
+
+if "processing" not in st.session_state:
+    st.session_state.processing = False
+
+# ============================================================================
+# Custom CSS
+# ============================================================================
+
+st.markdown("""
+<style>
+    /* Fixed bottom input container */
+    .stChatFloatingInputContainer {
+        position: sticky;
+        bottom: 0;
+        background-color: var(--background-color);
+        padding: 1rem 0;
+        z-index: 100;
+    }
+
+    .stChatMessage {
+        padding: 1rem;
+        border-radius: 0.5rem;
+        margin-bottom: 0.5rem;
+    }
+
+    .thinking-step {
+        background-color: #f0f2f6;
+        padding: 1rem;
+        border-radius: 0.5rem;
+        border-left: 3px solid #4CAF50;
+        margin: 0.5rem 0;
+    }
+
+    .action-step {
+        background-color: #fff3cd;
+        padding: 0.75rem 1rem;
+        border-radius: 0.5rem;
+        border-left: 3px solid #ffc107;
+        margin: 0.5rem 0;
+    }
+
+    .action-step-done {
+        background-color: #d4edda;
+        padding: 0.75rem 1rem;
+        border-radius: 0.5rem;
+        border-left: 3px solid #28a745;
+        margin: 0.5rem 0;
+    }
+
+    .observation-step {
+        background-color: #d1ecf1;
+        padding: 1rem;
+        border-radius: 0.5rem;
+        border-left: 3px solid #17a2b8;
+        margin: 0.5rem 0;
+    }
+
+    .agent-badge {
+        display: inline-block;
+        padding: 0.25rem 0.5rem;
+        border-radius: 0.25rem;
+        background-color: #6c757d;
+        color: white;
+        font-size: 0.875rem;
+        font-weight: 500;
+    }
+
+    /* Search references styling */
+    .search-references {
+        margin-top: 1rem;
+        padding: 0.75rem;
+        background-color: #f8f9fa;
+        border-radius: 0.5rem;
+        border-left: 3px solid #007bff;
+    }
+
+    .search-references h4 {
+        margin-top: 0;
+        font-size: 0.9rem;
+        color: #495057;
+    }
+
+    .search-references a {
+        display: block;
+        color: #007bff;
+        text-decoration: none;
+        margin: 0.25rem 0;
+        font-size: 0.85rem;
+    }
+
+    .search-references a:hover {
+        text-decoration: underline;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# ============================================================================
+# Sidebar
+# ============================================================================
+
+with st.sidebar:
+    st.title("🤖 Multi-Agent Assistant")
+    st.markdown("---")
+
+    # Settings
+    st.subheader("⚙️ Settings")
+    st.session_state.show_intermediate_steps = st.checkbox(
+        "Show Reasoning Steps",
+        value=st.session_state.show_intermediate_steps,
+        help="Display intermediate thinking, actions, and observations"
+    )
+
+    if st.button("🗑️ Clear Chat", use_container_width=True):
+        st.session_state.messages = []
+        st.session_state.chat_history = []
+        st.rerun()
+
+    st.markdown("---")
+
+    # Information
+    st.subheader("ℹ️ Available Agents")
+    st.markdown("""
+    - 🪙 **Crypto Agent**: Cryptocurrency prices & data
+    - 📊 **Stock Agent**: Stock market information
+    - 💼 **Finance Tracker**: Portfolio management
+    - 📚 **RAG Agent**: Document Q&A
+    - 🔍 **Search Agent**: Web search
+    """)
+
+    st.markdown("---")
+    st.caption("Powered by FastAPI + Gemini 2.5 Pro")
+
+# ============================================================================
+# Main Chat Interface
+# ============================================================================
+
+st.title("💬 Multi-Agent Chat Assistant")
+st.markdown("Ask questions about crypto, stocks, documents, or search the web!")
+
+# Container for chat messages
+chat_container = st.container()
+
+# Display chat history in the container
+with chat_container:
+    for message in st.session_state.messages:
+        role = message["role"]
+        content = message["content"]
+
+        with st.chat_message(role):
+            if role == "assistant" and "metadata" in message:
+                metadata = message["metadata"]
+
+                # Intermediate steps
+                if metadata.get("type") == "thinking":
+                    if st.session_state.show_intermediate_steps:
+                        with st.expander(f"💭 Step {metadata.get('step', '?')}: Reasoning", expanded=False):
+                            st.markdown(f"**Thought:** {metadata.get('thought', 'N/A')}")
+                            st.markdown(f"**Action:** `{metadata.get('action', 'N/A').upper()}`")
+                            st.markdown(f"**Justification:** {metadata.get('justification', 'N/A')}")
+
+                elif metadata.get("type") == "action":
+                    if st.session_state.show_intermediate_steps:
+                        agent = metadata.get('agent', 'unknown')
+                        status = metadata.get('status', 'running')
+                        if status == 'done':
+                            st.success(f"✅ **{agent.title()}** Agent - Done")
+                        else:
+                            st.info(f"🔧 Calling **{agent.title()}** Agent...")
+
+                elif metadata.get("type") == "observation":
+                    if st.session_state.show_intermediate_steps:
+                        agent = metadata.get('agent', 'unknown')
+                        with st.expander(f"📊 {agent.title()} Agent Results", expanded=False):
+                            st.write(content)
+
+                else:
+                    # Regular assistant message
+                    st.markdown(content)
+
+                    # Display search references if available
+                    if metadata.get("search_references"):
+                        refs = metadata["search_references"]
+                        st.markdown("---")
+                        st.markdown("**🔗 References:**")
+                        for ref in refs:
+                            st.markdown(f"- [{ref['title']}]({ref['url']})")
+            else:
+                # User or regular message
+                st.markdown(content)
+
+# Fixed bottom container for input and file upload
+st.markdown("---")
+input_col, upload_col = st.columns([4, 1])
+
+with input_col:
+    prompt = st.chat_input("Ask me anything...", key="chat_input")
+
+with upload_col:
+    uploaded_file = st.file_uploader(
+        "📄",
+        type=["pdf", "txt", "docx"],
+        help="Upload documents to the RAG agent",
+        label_visibility="collapsed",
+        key="file_uploader"
+    )
+
+# Handle document upload
+if uploaded_file and not st.session_state.processing:
+    with st.spinner("Uploading document..."):
+        result = upload_document(uploaded_file)
+        if result.get("success"):
+            st.success(f"✅ {result.get('message', 'Upload successful')}")
+        else:
+            st.error(f"❌ {result.get('message', 'Upload failed')}")
+
+# Handle chat input
+if prompt and not st.session_state.processing:
+    st.session_state.processing = True
+
+    # Add user message to chat
+    st.session_state.messages.append({"role": "user", "content": prompt})
+    st.session_state.chat_history.append({"role": "user", "content": prompt})
+
+    # Display user message
+    with chat_container:
+        with st.chat_message("user"):
+            st.markdown(prompt)
+
+        # Get response from API
+        with st.chat_message("assistant"):
+            # Create placeholders for streaming (thinking steps first, then final answer)
+            thinking_placeholder = st.container()
+            response_placeholder = st.empty()
+
+            final_answer = ""
+            current_step = 0
+            agent_status_placeholders = {}
+            search_references = []
+            first_event_received = False
+            initial_status = None
+
+            # Show initial status while supervisor starts processing
+            if st.session_state.show_intermediate_steps:
+                with thinking_placeholder:
+                    initial_status = st.empty()
+                    initial_status.info("🤔 Supervisor is analyzing your query...")
+
+            try:
+                for event in stream_chat_response(prompt, st.session_state.chat_history[:-1]):
+                    event_type = event.get("type", "unknown")
+
+                    # Clear initial status on first event
+                    if not first_event_received and initial_status is not None:
+                        initial_status.empty()
+                        first_event_received = True
+
+                    if event_type == "thinking":
+                        current_step = event.get("step", current_step + 1)
+                        if st.session_state.show_intermediate_steps:
+                            with thinking_placeholder:
+                                with st.expander(f"💭 Step {current_step}: Reasoning", expanded=False):
+                                    st.markdown(f"**Thought:** {event.get('thought', 'N/A')}")
+                                    st.markdown(f"**Action:** `{event.get('action', 'N/A').upper()}`")
+                                    st.markdown(f"**Justification:** {event.get('justification', 'N/A')}")
+
+                            st.session_state.messages.append({
+                                "role": "assistant",
+                                "content": "",
+                                "metadata": {
+                                    "type": "thinking",
+                                    "step": current_step,
+                                    "thought": event.get('thought', ''),
+                                    "action": event.get('action', ''),
+                                    "justification": event.get('justification', '')
+                                }
+                            })
+
+                    elif event_type == "action":
+                        agent = event.get("agent", "unknown")
+                        if st.session_state.show_intermediate_steps:
+                            with thinking_placeholder:
+                                # Create a placeholder for this agent's status
+                                agent_status_placeholders[agent] = st.empty()
+                                agent_status_placeholders[agent].info(f"🔧 Calling **{agent.title()}** Agent...")
+
+                            st.session_state.messages.append({
+                                "role": "assistant",
+                                "content": f"Calling {agent} agent...",
+                                "metadata": {"type": "action", "agent": agent, "status": "running"}
+                            })
+
+                    elif event_type == "observation":
+                        agent = event.get("agent", "unknown")
+                        summary = event.get("summary", "")
+
+                        # Update the agent status to done
+                        if agent in agent_status_placeholders:
+                            agent_status_placeholders[agent].success(f"✅ **{agent.title()}** Agent - Done")
+
+                        # Extract search URLs if this is the search agent
+                        if agent == "search" and event.get("search_urls"):
+                            for url_data in event.get("search_urls", []):
+                                if url_data not in search_references:
+                                    search_references.append(url_data)
+
+                        if st.session_state.show_intermediate_steps:
+                            with thinking_placeholder:
+                                with st.expander(f"📊 {agent.title()} Agent Results", expanded=False):
+                                    st.write(summary)
+
+                            # Update the message to mark as done
+                            for msg in reversed(st.session_state.messages):
+                                if (msg.get("role") == "assistant" and
+                                    msg.get("metadata", {}).get("type") == "action" and
+                                    msg.get("metadata", {}).get("agent") == agent):
+                                    msg["metadata"]["status"] = "done"
+                                    break
+
+                            st.session_state.messages.append({
+                                "role": "assistant",
+                                "content": summary,
+                                "metadata": {"type": "observation", "agent": agent}
+                            })
+
+                    elif event_type == "final_start":
+                        # Display synthesis status in thinking area, not at top
+                        if st.session_state.show_intermediate_steps:
+                            with thinking_placeholder:
+                                st.info("🔄 Synthesizing final answer...")
+
+                    elif event_type == "final_token":
+                        # Stream token by token (use write() to handle incomplete markdown)
+                        final_answer = event.get("accumulated", "")
+                        response_placeholder.write(final_answer)
+
+                    elif event_type == "final_complete":
+                        if final_answer:
+                            # Render final version with proper markdown
+                            response_placeholder.markdown(final_answer)
+
+                    elif event_type == "error":
+                        error_msg = event.get("error", "Unknown error")
+                        response_placeholder.error(f"❌ Error: {error_msg}")
+                        final_answer = f"Error: {error_msg}"
+
+            except Exception as e:
+                response_placeholder.error(f"❌ Connection Error: {str(e)}")
+                final_answer = f"Error: {str(e)}"
+
+    # Add final answer to chat history
+    if final_answer:
+        message_data = {
+            "role": "assistant",
+            "content": final_answer,
+            "metadata": {}
+        }
+
+        # Add search references if available
+        if search_references:
+            message_data["metadata"]["search_references"] = search_references
+
+        st.session_state.messages.append(message_data)
+        st.session_state.chat_history.append({
+            "role": "assistant",
+            "content": final_answer
+        })
+
+    st.session_state.processing = False
+    st.rerun()