Conductor Super Agent

A local-first AI system that aggregates conversations from Grok, ChatGPT, Gemini, and Antigravity into a unified knowledge base with persistent memory across all your AI interactions.

• Multi-Platform Aggregation: Combine conversations from all major AI platforms
• Semantic Search: RAG-based retrieval using ChromaDB vector database
• Persistent Memory: Never lose context across conversations
• Code Snippet Extraction: Automatically extracts and indexes code from all conversations
• Privacy First: Runs 100% locally on your machine
• Rich CLI Interface: Beautiful terminal interface with search and filtering

Double-click Start_Super_Agent.bat on your Desktop.

This will:

1. Auto-configure the environment
2. Install any missing dependencies (self-healing)
3. Launch the Multi-AI Super Agent interface

• Google Gemini (Primary, Auto-configured)
• Grok / xAI (Added via Desktop key)
• Perplexity (Search enabled)
• OpenAI (Fallback)
• Claude / Titan / Llama on AWS Bedrock — reach these through your own AWS account, no per-provider API key required. See AWS Bedrock below.

The conductor auto-detects whichever provider is configured. Bedrock is selected when AWS credentials are present and no higher-priority key is set — its calls go through Bedrock's model-agnostic Converse API, so switching models is just a BEDROCK_MODEL_ID change.

cd conductor_agent
pip install -r requirements.txt

Copy the example environment file and add your API keys:

copy .env.example .env

Edit .env and add your OpenAI API key:

OPENAI_API_KEY=sk-your-key-here

1. Go to chat.openai.com
2. Click your profile → Settings → Data Controls
3. Click "Export Data"
4. Download the ZIP file (you'll receive an email)
5. Extract conversations.json

• Method 1: Use Google Takeout
  • Select "Gemini Apps Activity"
  • Download and extract
• Method 2: Save conversations as HTML
  • Open conversation in browser
  • Right-click → Save As → HTML

• Export from Grok settings (ZIP format)

• Conversations are automatically available at:

  C:\Users\<username>\.gemini\antigravity\brain
  

Run the ingestion script to process and index your conversations:

# Ingest all platforms
python ingest.py --chatgpt "path/to/conversations.json" --gemini "path/to/gemini_export" --grok "path/to/grok_export.zip" --antigravity "C:/Users/jjc29/.gemini/antigravity/brain"

# Or just Antigravity (default)
python ingest.py

# Reset database and re-ingest
python ingest.py --reset --antigravity "C:/Users/jjc29/.gemini/antigravity/brain"

python -m cli.interactive

You: How did I implement authentication in previous projects?

You: /code python async patterns

You: /platform chatgpt explain RAG architecture

You: /stats

conductor_agent/
├── config/              # Configuration management
│   └── settings.py
├── data_processors/     # Platform-specific processors
│   ├── base_processor.py
│   ├── chatgpt_processor.py
│   ├── gemini_processor.py
│   ├── grok_processor.py
│   └── antigravity_processor.py
├── knowledge_base/      # Vector store and retrieval
│   ├── embeddings.py
│   ├── vector_store.py
│   └── retrieval.py
├── cli/                 # Command-line interface
│   └── interactive.py
├── utils/               # Utilities
│   └── logger.py
├── data/                # Data storage
│   ├── raw/            # Raw exports
│   ├── processed/      # Processed conversations
│   └── chroma_db/      # Vector database
├── ingest.py           # Data ingestion script
├── requirements.txt     # Python dependencies
└── .env.example        # Environment template

All settings can be configured in .env:

# LLM Configuration
CONDUCTOR_MODEL=gpt-4o-mini
EMBEDDING_MODEL=text-embedding-3-small

# Vector Database
CHROMA_PERSIST_DIR=./data/chroma_db

# Search Parameters
CHUNK_SIZE=1000
CHUNK_OVERLAP=200
TOP_K=5

# Data Paths
ANTIGRAVITY_BRAIN_DIR=C:/Users/jjc29/.gemini/antigravity/brain

1. Data Processing: Platform-specific processors parse and standardize conversations
2. Embedding Generation: Text is chunked and converted to semantic embeddings (OpenAI)
3. Vector Storage: Embeddings stored in ChromaDB for fast similarity search
4. Retrieval: Hybrid search with re-ranking by recency and relevance
5. Context: Retrieved conversations provide context for queries

• Ensure you've run ingest.py to load your data
• Check that your export files are in the correct format
• Run /stats to verify database has content

• Verify OPENAI_API_KEY is set in .env
• Ensure the key has sufficient credits

• Run pip install -r requirements.txt
• Ensure Python 3.9+ is installed

• Embedding Generation: ~1000 tokens/second with caching
• Search Speed: <500ms for most queries
• Storage: ~1MB per 100 conversations
• Cost: ~$0.10 per 1000 conversations (embeddings)

• 100% Local: All data stays on your machine
• No Telemetry: ChromaDB telemetry disabled
• API Calls: Only for embeddings (text only, no PII)

The web/voice API in api/server.py runs anywhere a Python container runs. The recommended target is Google Cloud Run with the API key stored in Secret Manager. Local Docker and Render also work.

At least one LLM provider key:

The container binds to 0.0.0.0:${PORT} (default 8080). Cloud Run / Render inject PORT automatically.

Reach Claude, Titan, Llama and other models through your own AWS account — no separate provider API key to manage, since auth rides on whatever AWS credentials the box already has. Calls go through Bedrock's model-agnostic Converse API, so switching models is just a BEDROCK_MODEL_ID change.

In the Bedrock console, pick your region and request access to the model(s) you want (e.g. a Claude model). Access is granted per-region and is usually instant. The region must be one where both Bedrock and that model are available (e.g. us-east-1).

• Bedrock API key (simplest): Bedrock console → API keys → Generate. Set AWS_BEARER_TOKEN_BEDROCK=....
• AWS access keys: an IAM user/role with bedrock:InvokeModel (and bedrock:InvokeModelWithResponseStream for streaming). IAM → Users → Security credentials → Create access key. Set AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY (plus AWS_SESSION_TOKEN for temporary STS creds).
• Instance role (AWS compute only): on EC2 / ECS / EKS / Lambda with an attached role that has Bedrock permissions, leave the above unset — boto3 picks up the role automatically. Just set AWS_REGION. (Cloud Run and Render don't provide AWS IAM roles to containers — use explicit credentials there; see Using Bedrock on Cloud Run / Render.)

BEDROCK_MODEL_ID defaults to anthropic.claude-3-5-sonnet-20240620-v1:0. List the exact IDs enabled in your account/region — some newer models are inference-profile only and need a region-prefixed id like us.anthropic.claude-3-5-sonnet-20241022-v2:0:

aws bedrock list-foundation-models --region us-east-1 \
  --query "modelSummaries[?providerName=='Anthropic'].modelId" --output table

docker run --rm -p 8080:8080 \
  -e AWS_REGION=us-east-1 \
  -e AWS_BEARER_TOKEN_BEDROCK=your_bedrock_api_key \
  -e BEDROCK_MODEL_ID=anthropic.claude-3-5-sonnet-20240620-v1:0 \
  conductor-agent

Confirm with /health — providers should include bedrock and api_keys_configured should be true.

docker build -t conductor-agent .
docker run --rm -p 8080:8080 -e OPENAI_API_KEY=sk-... conductor-agent
# or pass a whole .env file:
docker run --rm -p 8080:8080 --env-file .env conductor-agent

Open http://localhost:8080 and check /health — api_keys_configured should be true.

One-time setup (replace $PROJECT_ID):

gcloud config set project $PROJECT_ID
gcloud services enable run.googleapis.com \
  artifactregistry.googleapis.com \
  secretmanager.googleapis.com

# Store the key in Secret Manager
echo -n "sk-your-openai-key" | \
  gcloud secrets create openai-api-key --data-file=-

# Grant the Cloud Run runtime SA access (project-default Compute SA)
PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format='value(projectNumber)')
gcloud secrets add-iam-policy-binding openai-api-key \
  --member="serviceAccount:${PROJECT_NUMBER}-compute@developer.gserviceaccount.com" \
  --role="roles/secretmanager.secretAccessor"

Build + deploy:

gcloud run deploy conductor-agent \
  --source . \
  --region us-central1 \
  --allow-unauthenticated \
  --set-secrets OPENAI_API_KEY=openai-api-key:latest

The deploy URL appears at the end. Hit /health to confirm api_keys_configured: true.

To rotate the key:

echo -n "sk-new-key" | \
  gcloud secrets versions add openai-api-key --data-file=-
gcloud run services update conductor-agent --region us-central1 \
  --set-secrets OPENAI_API_KEY=openai-api-key:latest

The repo includes render.yaml. In the Render dashboard set OPENAI_API_KEY under Environment — do not commit it. Render injects PORT automatically.

Cloud Run and Render don't give containers AWS IAM roles the way EC2/ECS do, so pass explicit AWS credentials as secrets alongside AWS_REGION:

gcloud run deploy conductor-agent \
  --source . \
  --region us-central1 \
  --allow-unauthenticated \
  --set-env-vars AWS_REGION=us-east-1 \
  --set-secrets AWS_ACCESS_KEY_ID=aws-access-key-id:latest,AWS_SECRET_ACCESS_KEY=aws-secret-access-key:latest

Scope the IAM user/role to bedrock:InvokeModel and bedrock:InvokeModelWithResponseStream on the model ARNs you use. A Bedrock API key (AWS_BEARER_TOKEN_BEDROCK) works here too, as a single secret.

• [x ] LangGraph conductor orchestration with specialized sub-agents
• [ x] Web UI interface
• [x ] Support for more platforms (Claude, Perplexity)
• [ x] Real-time conversation sync
• [x ] Export to NotebookLM format
• [x ] Conversation analytics and insights

MIT License - Feel free to use and modify

This is a personal project, but feel free to fork and adapt for your needs!

Built with: Python, ChromaDB, OpenAI, LangChain, Rich CLI