diff --git a/.env.example b/.env.example
index 031d990..4c88b60 100644
--- a/.env.example
+++ b/.env.example
@@ -44,13 +44,21 @@ MOCK_MONGODB_DATABASE='test_database'
 # Set to "mock" to deactivate access, service removes auth from agent usage
 ACCESS_SERVICE = 'service' 
 
+# Authentication Configuration
+# Set to "true" to disable authentication (useful for local development/testing)
+# When disabled, all requests use a default user named "Default User"
+DISABLE_AUTH = 'false'  # Set to 'true' to disable authentication
+
+# Session and token configuration (not used when DISABLE_AUTH=true)
+SESSION_TOKEN_TTL = '15'  # Minutes
+REFRESH_TOKEN_TTL = '14'  # Days
+JWT_TOKEN_SECRET = 'your-secret-key-at-least-32-characters-long'
+
 ## Set google api-key
 GOOGLE_CLIENT_ID="your-google-api-key.apps.googleusercontent.com"
 # for encrypting access keys
 FERNET_KEY='your_fernet_key_here'
 
-# for authentication
-SESSION_JWT_TOKEN_SECRET="your secret here"
-
+# OAuth Configuration (not used when DISABLE_AUTH=true)
 GOOGLE_CLIENT_ID="your id"
 GOOGLE_CLIENT_SECRET="your secret here"
\ No newline at end of file
diff --git a/AUTHENTICATION_IMPLEMENTATION.md b/AUTHENTICATION_IMPLEMENTATION.md
new file mode 100644
index 0000000..01c6ddf
--- /dev/null
+++ b/AUTHENTICATION_IMPLEMENTATION.md
@@ -0,0 +1,243 @@
+# Authentication Feature Flag Implementation - Summary
+
+## ✅ Implementation Complete
+
+A feature flag system has been successfully implemented to disable authentication across the entire RAGdoll repository.
+
+## Changes Made
+
+### 1. Configuration (`src/config.py`)
+- ✅ Added `DISABLE_AUTH` environment variable
+- ✅ Defaults to `false` (auth enabled for security)
+- ✅ Reads from `.env` file
+
+### 2. AuthService (`src/auth/auth_service/auth_service.py`)
+- ✅ Added `_get_or_create_default_user()` method
+- ✅ Modified `login_user()` to bypass OAuth when disabled
+- ✅ Modified `auth()` to skip authorization checks when disabled
+- ✅ Modified `get_authenticated_user()` to return default user when disabled
+- ✅ Added logging on startup to show auth status
+- ✅ Caches default user for performance
+
+### 3. Authentication Routes (`src/routes/auth.py`)
+- ✅ Updated `/api/login` to return mock tokens when disabled
+- ✅ Updated `/api/refresh` to return mock tokens when disabled
+- ✅ Updated `/api/logout` to work without tokens when disabled
+- ✅ Added `/api/auth-status` endpoint to check current status
+
+### 4. Documentation
+- ✅ Created `docs/manuals/authentication_feature_flag.md`
+- ✅ Updated `.env.example` with DISABLE_AUTH configuration
+- ✅ Added usage examples and troubleshooting guide
+
+### 5. Testing
+- ✅ Created `test_auth_flag.py` verification script
+
+## Default User Details
+
+When `DISABLE_AUTH=true`, a system user is automatically created:
+
+```python
+{
+    "name": "Default User",
+    "email": "default@local.dev",
+    "auth_provider": "system",
+    "provider_user_id": "default_user",
+    "owned_agents": []  # Auto-managed
+}
+```
+
+## How to Use
+
+### Option 1: Environment Variable
+```bash
+export DISABLE_AUTH=true
+python -m uvicorn src.main:app --reload
+```
+
+### Option 2: .env File
+```bash
+# In .env
+DISABLE_AUTH=true
+```
+
+Then start your server normally.
+
+### Option 3: Programmatic (for scripts)
+```python
+import os
+os.environ["DISABLE_AUTH"] = "true"
+
+# Now import and use RAGdoll modules
+from src.auth.auth_service.auth_service import AuthService
+```
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────┐
+│            All Protected Routes                  │
+│  /update-agent/, /agents/, /upload/agent, etc.  │
+└────────────────┬────────────────────────────────┘
+                 │
+                 ▼
+┌─────────────────────────────────────────────────┐
+│         auth_service.get_authenticated_user()   │
+│                                                  │
+│   ┌──────────────────────────────────┐         │
+│   │  if DISABLE_AUTH:                 │         │
+│   │    return default_user            │         │
+│   │  else:                            │         │
+│   │    validate JWT token             │         │
+│   │    return real user               │         │
+│   └──────────────────────────────────┘         │
+└─────────────────────────────────────────────────┘
+                 │
+                 ▼
+        ┌────────────────┐
+        │   Default User  │
+        │  (Auto-created) │
+        └────────────────┘
+```
+
+## Affected Components
+
+### ✅ Automatically Handled
+- Agent creation/updates
+- Agent deletion
+- Agent listing
+- Document uploads
+- Document deletion
+- Document listing
+- API key management
+- All authentication endpoints
+
+### ℹ️ No Changes Needed
+- RAG pipeline execution
+- LLM integration
+- Embedding generation
+- Database operations
+- WebSocket connections (if any)
+
+## Security Notes
+
+⚠️ **NEVER use `DISABLE_AUTH=true` in production!**
+
+This feature is designed for:
+- ✅ Local development
+- ✅ Automated testing
+- ✅ CI/CD pipelines
+- ✅ Demo environments
+- ✅ Prototyping
+
+NOT for:
+- ❌ Production deployments
+- ❌ Public-facing services
+- ❌ Any system with real user data
+- ❌ Shared development servers
+
+## Testing the Implementation
+
+### Manual Testing
+
+1. **Check auth status:**
+   ```bash
+   curl http://localhost:8000/api/auth-status
+   ```
+
+2. **Login without credentials:**
+   ```bash
+   curl -X POST http://localhost:8000/api/login \
+     -H "Content-Type: application/json" \
+     -d '{"token": "any", "provider": "any"}'
+   ```
+
+3. **Create agent without auth:**
+   ```bash
+   curl -X POST http://localhost:8000/update-agent/ \
+     -H "Content-Type: application/json" \
+     -d '{"name": "Test", ...}'
+   ```
+
+### Automated Testing
+
+Run the verification script:
+```bash
+python test_auth_flag.py
+```
+
+## Logging
+
+With authentication disabled, you'll see:
+```
+🔓 AUTHENTICATION DISABLED - Using default user for all requests
+🔓 Login bypassed - authentication disabled
+🔓 Auth check bypassed for agent <id>
+🔓 Returning default user (auth disabled)
+```
+
+With authentication enabled:
+```
+🔒 Authentication enabled
+```
+
+## Migration Path
+
+### Enabling Auth (Production)
+1. Remove `DISABLE_AUTH=true` from .env (or set to `false`)
+2. Configure OAuth credentials
+3. Set `JWT_TOKEN_SECRET`
+4. Restart server
+5. Users must authenticate
+
+### Disabling Auth (Development)
+1. Add `DISABLE_AUTH=true` to .env
+2. Restart server
+3. Authentication bypassed automatically
+
+## Integration with Existing Code
+
+The implementation is **transparent** to existing code:
+
+- ✅ No changes needed to route handlers
+- ✅ No changes needed to business logic
+- ✅ No changes needed to database operations
+- ✅ Everything continues to work normally
+
+The `auth_service` acts as a smart proxy:
+- When `DISABLE_AUTH=true` → Returns default user
+- When `DISABLE_AUTH=false` → Validates JWT tokens
+
+## Files Modified
+
+1. `src/config.py` - Added DISABLE_AUTH config
+2. `src/auth/auth_service/auth_service.py` - Bypass logic
+3. `src/routes/auth.py` - Updated auth endpoints
+4. `.env.example` - Added configuration docs
+5. `docs/manuals/authentication_feature_flag.md` - Full documentation
+6. `test_auth_flag.py` - Verification script
+
+## Success Criteria
+
+✅ Authentication can be disabled via environment variable
+✅ Default user is created automatically
+✅ All routes work without JWT tokens when disabled
+✅ All routes require JWT tokens when enabled
+✅ System logs authentication status clearly
+✅ No breaking changes to existing functionality
+✅ Comprehensive documentation provided
+
+## Next Steps
+
+1. **Set DISABLE_AUTH=true in your .env file**
+2. **Restart your server**
+3. **Test without authentication**
+4. **Read full docs at `docs/manuals/authentication_feature_flag.md`**
+
+## Support
+
+If you encounter issues:
+1. Check `/api/auth-status` endpoint
+2. Verify `DISABLE_AUTH=true` in environment
+3. Check server logs for 🔓/🔒 messages
+4. Review `docs/manuals/authentication_feature_flag.md`
diff --git a/AUTH_QUICK_REF.md b/AUTH_QUICK_REF.md
new file mode 100644
index 0000000..2291250
--- /dev/null
+++ b/AUTH_QUICK_REF.md
@@ -0,0 +1,159 @@
+# 🔓 Authentication Feature Flag - Quick Reference
+
+## TL;DR
+
+Set `DISABLE_AUTH=true` in your `.env` file to disable all authentication in RAGdoll.
+
+## Quick Setup
+
+```bash
+# Option 1: Run the setup script
+python setup_no_auth.py
+
+# Option 2: Manual setup
+echo "DISABLE_AUTH=true" >> .env
+```
+
+## What It Does
+
+| Feature | Auth Enabled | Auth Disabled |
+|---------|-------------|---------------|
+| Login Required | ✅ Yes (OAuth) | ❌ No |
+| JWT Tokens | ✅ Required | ❌ Not needed |
+| User Management | ✅ Real users | ⚡ Default user |
+| Agent Ownership | ✅ Per user | ⚡ All accessible |
+| API Headers | ✅ Authorization required | ❌ None needed |
+
+## Environment Variable
+
+```bash
+# .env file
+DISABLE_AUTH=true   # ← Add this line
+```
+
+## Default User (Auto-created)
+
+```json
+{
+  "name": "Default User",
+  "email": "default@local.dev",
+  "auth_provider": "system",
+  "owned_agents": []  // Auto-managed
+}
+```
+
+## Example Usage
+
+### With Auth Disabled
+
+```bash
+# No headers needed!
+curl -X POST http://localhost:8000/update-agent/ \
+  -H "Content-Type: application/json" \
+  -d '{"name": "My Agent", ...}'
+```
+
+### With Auth Enabled
+
+```bash
+# Authorization header required
+curl -X POST http://localhost:8000/update-agent/ \
+  -H "Authorization: Bearer <jwt_token>" \
+  -H "Content-Type: application/json" \
+  -d '{"name": "My Agent", ...}'
+```
+
+## Check Status
+
+```bash
+curl http://localhost:8000/api/auth-status
+```
+
+Response:
+```json
+{
+  "auth_enabled": false,
+  "auth_disabled": true,
+  "message": "Authentication is disabled - using default user"
+}
+```
+
+## Affected Endpoints
+
+### Auth Endpoints
+- ✅ `/api/login` - Returns mock tokens
+- ✅ `/api/refresh` - Returns mock tokens  
+- ✅ `/api/logout` - Returns success
+- ✅ `/api/auth-status` - Shows current status
+
+### Protected Endpoints (No auth needed when disabled)
+- ✅ `/update-agent/` - Create/update agents
+- ✅ `/agents/` - List agents
+- ✅ `/delete-agent` - Delete agents
+- ✅ `/upload/agent` - Upload documents
+- ✅ `/documents/agent` - List documents
+- ✅ `/delete-document` - Delete documents
+- ✅ `/api-keys/*` - Manage API keys
+
+## Use Cases
+
+### ✅ Good For
+- Local development
+- Automated testing
+- CI/CD pipelines
+- Demos
+- Prototyping
+
+### ❌ Bad For
+- Production deployments
+- Public APIs
+- Real user data
+- Shared environments
+
+## Troubleshooting
+
+### Still getting 401 errors?
+
+1. Check .env has `DISABLE_AUTH=true`
+2. Restart server
+3. Verify with `/api/auth-status`
+4. Check logs for "🔓 AUTHENTICATION DISABLED"
+
+### Default user not working?
+
+Database permissions issue - check MongoDB/mock DB access
+
+## Files to Know
+
+| File | Purpose |
+|------|---------|
+| `.env` | Config (add `DISABLE_AUTH=true`) |
+| `setup_no_auth.py` | Auto-setup script |
+| `docs/manuals/authentication_feature_flag.md` | Full docs |
+| `AUTHENTICATION_IMPLEMENTATION.md` | Implementation summary |
+
+## Commands
+
+```bash
+# Setup
+python setup_no_auth.py
+
+# Start server
+uvicorn src.main:app --reload
+
+# Check status
+curl http://localhost:8000/api/auth-status
+
+# Test endpoint (no auth)
+curl -X GET http://localhost:8000/agents/
+```
+
+## Security Warning
+
+⚠️ **NEVER** set `DISABLE_AUTH=true` in production!
+
+## More Info
+
+- Full documentation: `docs/manuals/authentication_feature_flag.md`
+- Implementation details: `AUTHENTICATION_IMPLEMENTATION.md`
+- Code: `src/auth/auth_service/auth_service.py`
diff --git a/docs/manuals/authentication_feature_flag.md b/docs/manuals/authentication_feature_flag.md
new file mode 100644
index 0000000..543aab8
--- /dev/null
+++ b/docs/manuals/authentication_feature_flag.md
@@ -0,0 +1,218 @@
+# Authentication Feature Flag
+
+## Overview
+
+RAGdoll supports a feature flag to disable authentication for local development and testing. When `DISABLE_AUTH=true`, all authentication checks are bypassed and a default user is used for all operations.
+
+## Configuration
+
+### Enable/Disable Authentication
+
+In your `.env` file:
+
+```bash
+# Disable authentication (local development/testing)
+DISABLE_AUTH=true
+
+# Enable authentication (production - default)
+DISABLE_AUTH=false
+```
+
+## How It Works
+
+### When `DISABLE_AUTH=true`:
+
+1. **Authentication Bypass**: All auth checks in routes return immediately without validation
+2. **Default User**: A system user named "Default User" is automatically created and used
+3. **Mock Tokens**: Login/refresh endpoints return mock tokens instead of JWT tokens
+4. **Agent Ownership**: All agents are automatically owned by the default user
+5. **No OAuth Required**: Google OAuth credentials are not needed
+
+### Default User Details
+
+- **Name**: Default User
+- **Email**: default@local.dev
+- **Provider**: system
+- **Provider ID**: default_user
+- **Owned Agents**: Auto-managed (all agents accessible)
+
+## Affected Endpoints
+
+All authentication-related endpoints work differently when auth is disabled:
+
+### `/api/login` (POST)
+- **Normal**: Validates OAuth token, creates JWT tokens
+- **Disabled**: Returns mock tokens and default user info immediately
+
+### `/api/refresh` (POST)
+- **Normal**: Validates refresh token, issues new access token
+- **Disabled**: Returns mock token immediately
+
+### `/api/logout` (GET)
+- **Normal**: Revokes JWT token
+- **Disabled**: Returns success message immediately
+
+### `/api/auth-status` (GET)
+- **New endpoint**: Check if authentication is enabled or disabled
+
+### All Protected Routes
+- **Normal**: Require valid JWT token in Authorization header
+- **Disabled**: No token required, use default user automatically
+
+## Usage Examples
+
+### Starting Server with Auth Disabled
+
+```bash
+# Set in .env
+DISABLE_AUTH=true
+
+# Start server
+uvicorn src.main:app --reload
+```
+
+### Testing API Calls
+
+When auth is disabled, you can call endpoints without Authorization headers:
+
+```bash
+# Create an agent (no auth needed)
+curl -X POST http://localhost:8000/update-agent/ \
+  -H "Content-Type: application/json" \
+  -d '{
+    "name": "Test Agent",
+    "description": "Testing without auth",
+    ...
+  }'
+
+# Upload documents (no auth needed)
+curl -X POST http://localhost:8000/upload/agent?agent_id=123 \
+  -F "file=@document.pdf"
+```
+
+### Check Auth Status
+
+```bash
+curl http://localhost:8000/api/auth-status
+```
+
+Response when disabled:
+```json
+{
+  "auth_enabled": false,
+  "auth_disabled": true,
+  "message": "Authentication is disabled - using default user"
+}
+```
+
+## Running the Full Pipeline Script
+
+The `run_full_pipeline.py` script automatically respects the `DISABLE_AUTH` flag:
+
+```bash
+# With auth disabled (easier for testing)
+DISABLE_AUTH=true python run_full_pipeline.py
+
+# With auth enabled (requires OAuth setup)
+DISABLE_AUTH=false python run_full_pipeline.py
+```
+
+## Implementation Details
+
+### Config (`src/config.py`)
+- Reads `DISABLE_AUTH` environment variable
+- Defaults to `false` (auth enabled)
+
+### AuthService (`src/auth/auth_service/auth_service.py`)
+- Checks `config.DISABLE_AUTH` in all methods
+- Creates/caches default user when needed
+- Logs authentication status on startup
+
+### Routes
+All route handlers use `auth_service.get_authenticated_user()` which:
+- Returns default user when `DISABLE_AUTH=true`
+- Performs normal JWT validation when `DISABLE_AUTH=false`
+
+## Security Considerations
+
+⚠️ **WARNING**: Never enable `DISABLE_AUTH` in production environments!
+
+### Safe Use Cases
+✅ Local development
+✅ Automated testing
+✅ CI/CD pipelines
+✅ Demos and proof-of-concepts
+
+### Unsafe Use Cases
+❌ Production deployments
+❌ Public-facing APIs
+❌ Shared development environments
+❌ Any system with real user data
+
+## Logging
+
+When auth is disabled, you'll see log messages:
+
+```
+🔓 AUTHENTICATION DISABLED - Using default user for all requests
+🔓 Login bypassed - authentication disabled
+🔓 Auth check bypassed for agent xyz123
+🔓 Returning default user (auth disabled)
+```
+
+When auth is enabled:
+
+```
+🔒 Authentication enabled
+```
+
+## Troubleshooting
+
+### Issue: "Default user not found"
+**Solution**: The user is created automatically on first use. Check database permissions.
+
+### Issue: "Agent ownership errors"
+**Solution**: Ensure `DISABLE_AUTH=true` is set in your environment, not just .env file.
+
+### Issue: "Still getting 401 errors"
+**Solution**: 
+1. Verify `DISABLE_AUTH=true` in your .env
+2. Restart the server
+3. Check logs for "AUTHENTICATION DISABLED" message
+4. Try the `/api/auth-status` endpoint
+
+## Migration Guide
+
+### From Auth Enabled → Disabled
+
+1. Set `DISABLE_AUTH=true` in `.env`
+2. Restart server
+3. Default user is created automatically
+4. All existing agents remain accessible
+
+### From Auth Disabled → Enabled
+
+1. Set `DISABLE_AUTH=false` in `.env`
+2. Configure OAuth credentials (Google)
+3. Set `JWT_TOKEN_SECRET`
+4. Restart server
+5. Users must log in via OAuth
+6. Reassign agent ownership as needed
+
+## Related Files
+
+- `src/config.py` - Feature flag configuration
+- `src/auth/auth_service/auth_service.py` - Authentication bypass logic
+- `src/routes/auth.py` - Auth endpoint modifications
+- `src/globals.py` - AuthService initialization
+- `.env.example` - Configuration template
+
+## Future Enhancements
+
+Potential improvements to the auth system:
+
+- [ ] Support multiple default users
+- [ ] Custom default user configuration
+- [ ] Auth simulation mode (test with fake tokens)
+- [ ] Per-endpoint auth override
+- [ ] Detailed auth metrics/logging
diff --git a/pipeline_GENERATED.py b/pipeline_GENERATED.py
new file mode 100644
index 0000000..0145448
--- /dev/null
+++ b/pipeline_GENERATED.py
@@ -0,0 +1,314 @@
+# Imports
+import logging
+from contextlib import asynccontextmanager
+from typing import Optional
+import os
+
+from fastapi import FastAPI, HTTPException, WebSocket, WebSocketDisconnect
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+import uvicorn
+
+from src.pipeline import assemble_prompt_with_agent
+from src.models.chat.command import Command
+from src.models.chat.message import Message
+from src.routes.agents import create_agent, new_access_key
+from src.models.agent import Agent, Role
+from src.routes.api_keys import CreateAPIKeyRequest, create_api_key, get_api_key_detail
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Global agent storage
+PIPELINE_AGENT: Optional[Agent] = None
+AGENT_CONFIG = {}
+
+def initialize_pipeline_agent():
+    global PIPELINE_AGENT, AGENT_CONFIG
+    logger.info("=" * 80)
+    logger.info("Initializing Pipeline Agent")
+    logger.info("=" * 80)
+
+    llm_secret_key = "sk-dbc483d4e3c3479e9be50e91d190d5d9"
+    gemini_secret_key = "AIzaSyDkkf-UFm-6tgmrEbpONaK-KVnLmewJZDs"
+
+    api_request = CreateAPIKeyRequest(
+        label="idunLLM",
+        provider="idun",
+        usage="llm",
+        raw_key=llm_secret_key
+    )
+    api_key_llm_response = create_api_key(api_request)
+    api_key_llm_detail = get_api_key_detail(api_key_llm_response.id)
+
+    api_request_embedding = CreateAPIKeyRequest(
+        label="geminiEmbedded",
+        provider="gemini",
+        usage="embedding",
+        raw_key=gemini_secret_key
+    )
+    api_key_embedding_response = create_api_key(api_request_embedding)
+    api_key_embedding_detail = get_api_key_detail(api_key_embedding_response.id)
+
+	#Roles
+    roles = [Role(name="TEACHER", description="talk like a STEM professor, but specializing in brainrot terms", document_access=["trex.pdf"])
+,Role(name="STUDENT", description="talk like a skater bro, but somehow you know everything in the universe", document_access=["trex.pdf"])
+]
+    logger.info(f"Created {len(roles)} roles")
+    #Agent
+    agent_body = Agent(
+        id="6932698c69151632bf86532f", # Hardcoded Agent ID
+        name="tobias",
+        description="tutor but not AI",
+        prompt="",
+        roles=roles,
+        llm_provider="idun",
+        llm_model="openai/gpt-oss-120b",
+        llm_temperature=0.500000,
+        llm_max_tokens=1000,
+        llm_api_key=api_key_llm_detail.raw_key,
+        access_key=[],
+        retreival_method="hybrid",
+        embedding_model="gemini:models/text-embedding-004",
+        status="active",
+        response_format="text",
+        last_updated="2024-06-01T12:00:00Z",
+        embedding_api_key=api_key_embedding_detail.raw_key,
+        topK=3,
+        similarity_threshold=0.500000,
+        hybrid_search_alpha=0.600000,
+    )
+    agent = create_agent(agent_body)
+    logger.info(f"Created agent: {agent.name} (ID: {agent.id})")
+
+    access_key = new_access_key(name="access_key1", agent_id=agent.id)
+    agent.access_key.append(access_key)
+    logger.info(f"Created access key")
+
+    PIPELINE_AGENT = agent
+    AGENT_CONFIG = {
+        "id": agent.id,
+        "name": agent.name,
+        "description": agent.description,
+        "roles": [{"name": r.name, "description": r.description} for r in agent.roles],
+        "llm_provider": agent.llm_provider,
+        "llm_model": agent.llm_model,
+        "embedding_model": agent.embedding_model,
+        "top_k": agent.top_k,
+        "similarity_threshold": agent.similarity_threshold,
+    }
+
+    logger.info("=" * 80)
+    logger.info(f"Agent ID: {agent.id}")
+    logger.info(f"Agent Name: {agent.name}")
+    logger.info(f"Roles: {', '.join([r.name for r in agent.roles])}")
+    logger.info("=" * 80)
+
+# FastAPI lifecycle
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    logger.info("Starting Model-Driven Agent Server")
+    try:
+        initialize_pipeline_agent()
+    except Exception as e:
+        logger.error(f"Failed to initialize pipeline agent: {e}")
+        raise
+    yield
+    logger.info("Shutting down Model-Driven Agent Server")
+
+app = FastAPI(
+    title="Model-Driven Agent Server",
+    description="Local pipeline server for model-driven agent interaction",
+    version="1.0.0",
+    lifespan=lifespan
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:3001", "http://localhost:3000"],  # Frontend URLs
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+class ChatMessage(BaseModel):
+    role: str
+    content: str
+
+class ChatRequest(BaseModel):
+    messages: list[ChatMessage]
+    active_role_id: str = "CrazyFrog" # Default to first role
+
+class ChatResponse(BaseModel):
+    response: str
+    agent_id: str
+    agent_name: str
+    role: str
+    contexts_used: int
+    contexts: list[dict]
+
+@app.get("/")
+async def root():
+    return {
+        "status": "running",
+        "mode": "model-driven",
+        "agent": AGENT_CONFIG if PIPELINE_AGENT else None
+    }
+
+@app.get("/api/agent")
+async def get_agent():
+    if not PIPELINE_AGENT:
+        raise HTTPException(status_code=503, detail="Pipeline agent not initialized")
+    return {
+        "id": PIPELINE_AGENT.id,
+        "name": PIPELINE_AGENT.name,
+        "description": PIPELINE_AGENT.description,
+        "prompt": PIPELINE_AGENT.prompt,
+        "roles": [
+            {
+                "name": r.name,
+                "description": r.description,
+                "document_access": r.document_access
+            }
+            for r in PIPELINE_AGENT.roles
+        ],
+        "llm_provider": PIPELINE_AGENT.llm_provider,
+        "llm_model": PIPELINE_AGENT.llm_model,
+        "embedding_model": PIPELINE_AGENT.embedding_model,
+        "status": PIPELINE_AGENT.status,
+        "access_key": PIPELINE_AGENT.access_key[0] if PIPELINE_AGENT.access_key else None,
+    }
+
+@app.get("/api/agents")
+async def list_agents():
+    if not PIPELINE_AGENT:
+        return {"agents": []}
+    return {
+        "agents": [AGENT_CONFIG]
+    }
+
+@app.post("/api/chat", response_model=ChatResponse)
+async def chat(request: ChatRequest):
+    if not PIPELINE_AGENT:
+        raise HTTPException(status_code=503, detail="Pipeline agent not initialized")
+    try:
+        chat_log = [
+            Message(role=msg.role, content=msg.content)
+            for msg in request.messages
+        ]
+
+        command = Command(
+            chat_log=chat_log,
+            agent_id=PIPELINE_AGENT.id,
+            active_role_id=request.active_role_id,
+        )
+
+        result = assemble_prompt_with_agent(command, PIPELINE_AGENT)
+
+        contexts = []
+        if result.get("context_used"):
+            contexts = [
+                {
+                    "document_name": ctx["document_name"],
+                    "chunk_index": ctx["chunk_index"],
+                    "content": ctx["content"]
+                }
+                for ctx in result["context_used"]
+            ]
+
+        logger.info(f"   Response generated ({len(result['response'])} chars)")
+        logger.info(f"   Contexts used: {len(contexts)}")
+
+        return ChatResponse(
+            response=result["response"],
+            agent_id=PIPELINE_AGENT.id,
+            agent_name=PIPELINE_AGENT.name,
+            role=request.active_role_id,
+            contexts_used=len(contexts),
+            contexts=contexts
+        )
+
+    except Exception as e:
+        logger.error(f"Error processing chat: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.websocket("/ws/chat/{agent_id}")
+async def websocket_chat(websocket: WebSocket, agent_id: str):
+    await websocket.accept()
+
+    if not PIPELINE_AGENT or agent_id != PIPELINE_AGENT.id:
+        await websocket.send_json({
+            "error": "Agent not found or not initialized"
+        })
+        await websocket.close()
+        return
+
+    logger.info(f"WebSocket connection established for agent {agent_id}")
+
+    try:
+        while True:
+            data = await websocket.receive_json()
+
+            messages = data.get("messages", [])
+            active_role = data.get("active_role_id", "assistant")
+
+            chat_log = [
+                Message(role=msg["role"], content=msg["content"])
+                for msg in messages
+            ]
+
+            command = Command(
+	            chat_log=chat_log,
+                agent_id=PIPELINE_AGENT.id,
+                active_role_id=active_role,
+            )
+
+            result = assemble_prompt_with_agent(command, PIPELINE_AGENT)
+
+            await websocket.send_json({
+                "type": "response",
+                "response": result["response"],
+                "contexts_used": result["metadata"]["num_context_retrieved"],
+                "agent_name": PIPELINE_AGENT.name
+            })
+
+    except WebSocketDisconnect:
+        logger.info(f"WebSocket disconnected for agent {agent_id}")
+    except Exception as e:
+        logger.error(f"WebSocket error: {e}")
+        await websocket.send_json({"error": str(e)})
+        await websocket.close()
+
+
+def main():
+    port = int(os.getenv("MODEL_DRIVEN_PORT", "8001"))
+    host = os.getenv("MODEL_DRIVEN_HOST", "0.0.0.0")
+
+    logger.info("=" * 80)
+    logger.info("Starting Model-Driven Agent Server")
+    logger.info("=" * 80)
+    logger.info(f"Host: {host}")
+    logger.info(f"Port: {port}")
+    logger.info(f"Endpoints:")
+    logger.info(f"  - GET  /                      - Health check")
+    logger.info(f"  - GET  /api/agent/{{agent_id}}  - Get agent config")
+    logger.info(f"  - GET  /api/agents            - List agents")
+    logger.info(f"  - POST /api/chat              - Chat with agent")
+    logger.info(f"  - WS   /ws/chat/{{agent_id}}   - WebSocket chat")
+    logger.info("=" * 80)
+
+    uvicorn.run(
+        app,
+        host=host,
+        port=port,
+        log_level="info"
+    )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/run_full_pipeline.py b/run_full_pipeline.py
new file mode 100644
index 0000000..1679f3c
--- /dev/null
+++ b/run_full_pipeline.py
@@ -0,0 +1,102 @@
+
+
+import os
+
+from src.pipeline import assemble_prompt_with_agent, generate_retrieval_query
+from src.models.chat.command import Command
+from src.routes.agents import create_agent, new_access_key
+from src.models.agent import Agent, Role
+from src.routes.api_keys import CreateAPIKeyRequest, create_api_key, get_api_key_detail
+
+
+# Store the raw keys before creating UserAPIKey objects
+llm_secret_key = os.getenv("IDUN_API_KEY")
+gemini_secret_key = os.getenv("GEMINI_API_KEY")
+
+llm_model_label = "model1"
+llm_provider = "Idun"
+llm_usage = "llm"
+
+api_request = CreateAPIKeyRequest(
+    label=llm_model_label,
+    provider=llm_provider,
+    usage=llm_usage,
+    raw_key=llm_secret_key
+)
+api_key_llm_response = create_api_key(api_request)
+
+print("Created API Key for LLM:", api_key_llm_response)
+print("API Key ID:", api_key_llm_response.id)
+
+# Get the full details with raw key
+api_key_llm_detail = get_api_key_detail(api_key_llm_response.id)
+print(f"Retrieved raw LLM key: {api_key_llm_detail.raw_key[:10]}...{api_key_llm_detail.raw_key[-4:]}")
+
+api_request_embedding = CreateAPIKeyRequest(
+    label="embedding_key",
+    provider="gemini",
+    usage="embedding",
+    raw_key=gemini_secret_key
+)
+api_key_embedding_response = create_api_key(api_request_embedding)
+
+print("Created API Key for Embedding:", api_key_embedding_response)
+print("API Key ID:", api_key_embedding_response.id)
+
+# Get the full details with raw key
+api_key_embedding_detail = get_api_key_detail(api_key_embedding_response.id)
+print(f"Retrieved raw Embedding key: {api_key_embedding_detail.raw_key[:10]}...{api_key_embedding_detail.raw_key[-4:]}")
+
+role1 = Role(name="CrazyFrog", description="You are crazyfrog")
+role2 = Role(name="Crazy frog", description="You are an clinically insane amphibian. You speak only in either frog language or overly sophisticated English.")
+
+agent_body = Agent(
+    name ="Test Agent",
+    description="An agent for testing API key creation",
+    prompt="You are a helpful assistant.",
+    roles=[role1, role2],
+    llm_provider=llm_provider,
+    llm_model=os.getenv("IDUN_MODEL"),
+    llm_temperature=0.7,
+    llm_max_tokens=1000,
+    llm_api_key=api_key_llm_detail.raw_key,  
+    access_key=[],
+    retrieval_method="semantic",
+    embedding_model="models/text-embedding-004",
+    status="active",
+    response_format="text",
+    last_updated="2024-06-01T12:00:00Z",
+    embedding_api_key=api_key_embedding_detail.raw_key,  
+    
+    top_k=5,
+    similarity_threshold=0.7,
+    hybrid_search_alpha=0.75,   
+)
+
+agent = create_agent(agent_body)
+print("Created Agent:", agent)
+
+access_key = new_access_key(name="access_key1", agent_id=agent.id)
+
+agent.access_key.append(access_key)
+
+
+command = Command(
+    chat_log=[
+        {"role": "user", "content": "Hello"},
+        {"role": "user", "content": "what are flamingos?"},
+    ],
+    agent_id=agent.id,
+    active_role_id="CrazyFrog",
+)
+
+
+response = assemble_prompt_with_agent(command, agent)
+
+print("Generated Response:")
+print(response["response"])
+
+
+
+
+
diff --git a/run_full_pipeline_server.py b/run_full_pipeline_server.py
new file mode 100644
index 0000000..434f71c
--- /dev/null
+++ b/run_full_pipeline_server.py
@@ -0,0 +1,407 @@
+"""
+Model-Driven Agent Server
+
+This script runs the full RAGdoll pipeline and exposes it as a local API server.
+When the frontend has USE_MODEL_DRIVEN_AGENT=true, it connects to this server
+instead of the main API, allowing for direct pipeline interaction.
+
+This enables:
+- Rapid prototyping without deploying to main API
+- Testing new agent configurations locally
+- Direct pipeline debugging
+- Isolated agent development
+"""
+
+import os
+import json
+import logging
+from contextlib import asynccontextmanager
+from typing import Optional
+
+from fastapi import FastAPI, HTTPException, WebSocket, WebSocketDisconnect
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+import uvicorn
+
+from src.pipeline import assemble_prompt_with_agent
+from src.models.chat.command import Command
+from src.models.chat.message import Message
+from src.routes.agents import create_agent, new_access_key
+from src.models.agent import Agent, Role
+from src.routes.api_keys import CreateAPIKeyRequest, create_api_key, get_api_key_detail
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Global agent storage
+PIPELINE_AGENT: Optional[Agent] = None
+AGENT_CONFIG = {}
+
+
+def initialize_pipeline_agent():
+    """Initialize the agent that will be used in the pipeline."""
+    global PIPELINE_AGENT, AGENT_CONFIG
+    
+    logger.info("=" * 80)
+    logger.info("Initializing Pipeline Agent")
+    logger.info("=" * 80)
+    
+
+    
+    llm_secret_key = os.getenv("IDUN_API_KEY")
+    if not llm_secret_key:
+        raise ValueError("IDUN_API_KEY environment variable not set")
+    
+    gemini_secret_key = os.getenv("GEMINI_API_KEY")
+    if not gemini_secret_key:
+        raise ValueError("GEMINI_API_KEY environment variable not set")
+    
+    # Create LLM API key
+    api_request_llm = CreateAPIKeyRequest(
+        label="pipeline_llm_key",
+        provider="idun",
+        usage="llm",
+        raw_key=llm_secret_key
+    )
+    api_key_llm_response = create_api_key(api_request_llm)
+    api_key_llm_detail = get_api_key_detail(api_key_llm_response.id)
+    
+    api_request_embedding = CreateAPIKeyRequest(
+        label="pipeline_embedding_key",
+        provider="gemini",
+        usage="embedding",
+        raw_key=gemini_secret_key
+    )
+    api_key_embedding_response = create_api_key(api_request_embedding)
+    api_key_embedding_detail = get_api_key_detail(api_key_embedding_response.id)
+    logger.info(f"Created Embedding API key: {api_key_embedding_response.id}")
+    
+    
+    roles = [
+        Role(
+            name="CrazyFrog",
+            description="You are crazyfrog. You act like CrazyFrog from the internet memes.",
+            document_access=["trex.pdf", "Tralalero Tralala.pdf"]
+        ),
+        Role(
+            name="Crazy frog",
+            description="You are an clinically insane amphibian. You speak only in either frog language or overly sophisticated English.",
+            document_access=["trex.pdf", "Tralalero Tralala.pdf"]
+        ),
+        Role(
+            name="Crazy Zebra",
+            description="You are a zebra with a wild imagination. You often confuse reality with fantasy.",
+            document_access=["trex.pdf", "Initial research on methods to build a knowledge graph.pdf"]
+        )
+    ]
+    logger.info(f"Created {len(roles)} roles")
+    
+    agent_body = Agent(
+        id="6932698c69151632bf86532f",  # Hardcoded agent ID to match uploaded documents
+        name="Pipeline Test Agent",
+        description="An agent for testing the model-driven pipeline",
+        prompt=(
+            "Fuck around and find out."
+        ),
+        roles=roles,
+        llm_provider="idun",
+        llm_model=os.getenv("IDUN_MODEL", "openai/gpt-oss-120b"),
+        llm_temperature=0.7,
+        llm_max_tokens=1000,
+        llm_api_key=api_key_llm_detail.raw_key,
+        access_key=[],
+        retrieval_method="hybrid",
+        embedding_model="gemini:models/text-embedding-004",
+        status="active",
+        response_format="text",
+        last_updated="2024-06-01T12:00:00Z",
+        embedding_api_key=api_key_embedding_detail.raw_key,
+        top_k=5,
+        similarity_threshold=0.7,
+        hybrid_search_alpha=0.75,
+    )
+    
+    agent = create_agent(agent_body)
+    logger.info(f"Created agent: {agent.name} (ID: {agent.id})")
+    
+    # Create access key
+    access_key = new_access_key(name="pipeline_access_key", agent_id=agent.id)
+    agent.access_key.append(access_key)
+    logger.info(f"Created access key")
+    
+    PIPELINE_AGENT = agent
+    AGENT_CONFIG = {
+        "id": agent.id,
+        "name": agent.name,
+        "description": agent.description,
+        "roles": [{"name": r.name, "description": r.description} for r in agent.roles],
+        "llm_provider": agent.llm_provider,
+        "llm_model": agent.llm_model,
+        "embedding_model": agent.embedding_model,
+        "top_k": agent.top_k,
+        "similarity_threshold": agent.similarity_threshold,
+    }
+    
+    logger.info("=" * 80)
+    logger.info(f"Agent ID: {agent.id}")
+    logger.info(f"Agent Name: {agent.name}")
+    logger.info(f"Roles: {', '.join([r.name for r in agent.roles])}")
+    logger.info("=" * 80)
+    
+    return agent
+
+
+# FastAPI lifecycle
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Initialize agent on startup, cleanup on shutdown."""
+    logger.info("Starting Model-Driven Agent Server")
+    
+    # Startup
+    try:
+        initialize_pipeline_agent()
+    except Exception as e:
+        logger.error(f"Failed to initialize pipeline agent: {e}")
+        raise
+    
+    yield
+    
+    # Shutdown
+    logger.info("Shutting down Model-Driven Agent Server")
+
+
+# Create FastAPI app
+app = FastAPI(
+    title="Model-Driven Agent Server",
+    description="Local pipeline server for model-driven agent interaction",
+    version="1.0.0",
+    lifespan=lifespan
+)
+
+# Configure CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:3001", "http://localhost:3000"],  # Frontend URLs
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# Pydantic models for requests/responses
+class ChatMessage(BaseModel):
+    role: str
+    content: str
+
+
+class ChatRequest(BaseModel):
+    messages: list[ChatMessage]
+    active_role_id: str = "CrazyFrog" # Default to first role
+
+
+class ChatResponse(BaseModel):
+    response: str
+    agent_id: str
+    agent_name: str
+    role: str
+    contexts_used: int
+    contexts: list[dict]
+
+
+# API Endpoints
+
+@app.get("/")
+async def root():
+    """Health check endpoint."""
+    return {
+        "status": "running",
+        "mode": "model-driven",
+        "agent": AGENT_CONFIG if PIPELINE_AGENT else None
+    }
+
+
+@app.get("/api/agent")
+async def get_agent():
+    """Get the initialized agent configuration."""
+    if not PIPELINE_AGENT:
+        raise HTTPException(status_code=503, detail="Pipeline agent not initialized")
+    
+    return {
+        "id": PIPELINE_AGENT.id,
+        "name": PIPELINE_AGENT.name,
+        "description": PIPELINE_AGENT.description,
+        "prompt": PIPELINE_AGENT.prompt,
+        "roles": [
+            {
+                "name": r.name,
+                "description": r.description,
+                "document_access": r.document_access
+            }
+            for r in PIPELINE_AGENT.roles
+        ],
+        "llm_provider": PIPELINE_AGENT.llm_provider,
+        "llm_model": PIPELINE_AGENT.llm_model,
+        "embedding_model": PIPELINE_AGENT.embedding_model,
+        "status": PIPELINE_AGENT.status,
+        "access_key": PIPELINE_AGENT.access_key[0] if PIPELINE_AGENT.access_key else None,
+    }
+
+
+@app.get("/api/agents")
+async def list_agents():
+    """List all available agents (in this case, just the pipeline agent)."""
+    if not PIPELINE_AGENT:
+        return {"agents": []}
+    
+    return {
+        "agents": [AGENT_CONFIG]
+    }
+
+
+@app.post("/api/chat", response_model=ChatResponse)
+async def chat(request: ChatRequest):
+    """
+    Main chat endpoint - processes messages through the pipeline.
+    
+    This endpoint:
+    1. Receives chat messages from the frontend
+    2. Constructs a Command object
+    3. Runs it through assemble_prompt_with_agent
+    4. Returns the response with context information
+    """
+    if not PIPELINE_AGENT:
+        raise HTTPException(status_code=503, detail="Pipeline agent not initialized")
+    
+    
+    try:
+        chat_log = [
+            Message(role=msg.role, content=msg.content)
+            for msg in request.messages
+        ]
+        
+        command = Command(
+            chat_log=chat_log,
+            agent_id=PIPELINE_AGENT.id,
+            active_role_id=request.active_role_id,
+        )
+        
+        result = assemble_prompt_with_agent(command, PIPELINE_AGENT)
+        
+        contexts = []
+        if result.get("context_used"):
+            contexts = [
+                {
+                    "document_name": ctx["document_name"],
+                    "chunk_index": ctx["chunk_index"],
+                    "content": ctx["content"]
+                }
+                for ctx in result["context_used"]
+            ]
+        
+        logger.info(f"   Response generated ({len(result['response'])} chars)")
+        logger.info(f"   Contexts used: {len(contexts)}")
+        
+        return ChatResponse(
+            response=result["response"],
+            agent_id=PIPELINE_AGENT.id,
+            agent_name=PIPELINE_AGENT.name,
+            role=request.active_role_id,
+            contexts_used=len(contexts),
+            contexts=contexts
+        )
+        
+    except Exception as e:
+        logger.error(f"Error processing chat: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.websocket("/ws/chat/{agent_id}")
+async def websocket_chat(websocket: WebSocket, agent_id: str):
+    """
+    WebSocket endpoint for real-time chat.
+    
+    This enables streaming responses and maintains a persistent connection.
+    """
+    await websocket.accept()
+    
+    if not PIPELINE_AGENT or agent_id != PIPELINE_AGENT.id:
+        await websocket.send_json({
+            "error": "Agent not found or not initialized"
+        })
+        await websocket.close()
+        return
+    
+    logger.info(f"WebSocket connection established for agent {agent_id}")
+    
+    try:
+        while True:
+            # Receive message from client
+            data = await websocket.receive_json()
+            
+            messages = data.get("messages", [])
+            active_role = data.get("active_role_id", "assistant")
+            
+            # Convert to Message objects
+            chat_log = [
+                Message(role=msg["role"], content=msg["content"])
+                for msg in messages
+            ]
+            
+            # Create command
+            command = Command(
+                chat_log=chat_log,
+                agent_id=PIPELINE_AGENT.id,
+                active_role_id=active_role,
+            )
+            
+            # Run through pipeline
+            result = assemble_prompt_with_agent(command, PIPELINE_AGENT)
+            
+            # Send response back
+            await websocket.send_json({
+                "type": "response",
+                "response": result["response"],
+                "contexts_used": result["metadata"]["num_context_retrieved"],
+                "agent_name": PIPELINE_AGENT.name
+            })
+            
+    except WebSocketDisconnect:
+        logger.info(f"WebSocket disconnected for agent {agent_id}")
+    except Exception as e:
+        logger.error(f"WebSocket error: {e}")
+        await websocket.send_json({"error": str(e)})
+        await websocket.close()
+
+
+def main():
+    """Run the server."""
+    port = int(os.getenv("MODEL_DRIVEN_PORT", "8001"))
+    host = os.getenv("MODEL_DRIVEN_HOST", "0.0.0.0")
+    
+    logger.info("=" * 80)
+    logger.info("Starting Model-Driven Agent Server")
+    logger.info("=" * 80)
+    logger.info(f"Host: {host}")
+    logger.info(f"Port: {port}")
+    logger.info(f"Endpoints:")
+    logger.info(f"  - GET  /                      - Health check")
+    logger.info(f"  - GET  /api/agent/{{agent_id}}  - Get agent config")
+    logger.info(f"  - GET  /api/agents            - List agents")
+    logger.info(f"  - POST /api/chat              - Chat with agent")
+    logger.info(f"  - WS   /ws/chat/{{agent_id}}   - WebSocket chat")
+    logger.info("=" * 80)
+    
+    uvicorn.run(
+        app,
+        host=host,
+        port=port,
+        log_level="info"
+    )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/setup_no_auth.py b/setup_no_auth.py
new file mode 100644
index 0000000..b7f128e
--- /dev/null
+++ b/setup_no_auth.py
@@ -0,0 +1,108 @@
+"""
+Quick setup script for disabling authentication in RAGdoll.
+This creates/updates your .env file with DISABLE_AUTH=true.
+"""
+
+import os
+from pathlib import Path
+
+def setup_no_auth():
+    """Setup RAGdoll with authentication disabled."""
+    
+    print("=" * 70)
+    print("RAGdoll Authentication Disable Setup")
+    print("=" * 70)
+    
+    env_file = Path(".env")
+    
+    # Check if .env exists
+    if not env_file.exists():
+        print("\n⚠ No .env file found. Creating from .env.example...")
+        
+        example_file = Path(".env.example")
+        if example_file.exists():
+            content = example_file.read_text()
+            env_file.write_text(content)
+            print("✓ Created .env from .env.example")
+        else:
+            print("✗ .env.example not found!")
+            print("  Creating minimal .env file...")
+            minimal_content = """# RAGdoll Configuration
+ENV=dev
+DISABLE_AUTH=true
+FERNET_KEY=your_fernet_key_here_generate_with_python
+
+# Database (use mock for testing)
+MOCK_RAG_DATABASE_SYSTEM=mock
+
+# LLM Configuration
+MODEL=gemini
+GEMINI_API_KEY=your_gemini_api_key_here
+"""
+            env_file.write_text(minimal_content)
+            print("✓ Created minimal .env file")
+    
+    # Read current content
+    content = env_file.read_text()
+    lines = content.split('\n')
+    
+    # Check if DISABLE_AUTH exists
+    has_disable_auth = any('DISABLE_AUTH' in line for line in lines)
+    
+    if has_disable_auth:
+        # Update existing DISABLE_AUTH line
+        new_lines = []
+        for line in lines:
+            if 'DISABLE_AUTH' in line and not line.strip().startswith('#'):
+                new_lines.append('DISABLE_AUTH=true')
+                print(f"\n✓ Updated existing DISABLE_AUTH to true")
+            else:
+                new_lines.append(line)
+        content = '\n'.join(new_lines)
+    else:
+        # Add DISABLE_AUTH
+        # Find a good place to add it (after ENV or at the start)
+        insert_index = 0
+        for i, line in enumerate(lines):
+            if 'ENV' in line:
+                insert_index = i + 1
+                break
+        
+        lines.insert(insert_index, '')
+        lines.insert(insert_index + 1, '# Disable authentication (for local dev/testing)')
+        lines.insert(insert_index + 2, 'DISABLE_AUTH=true')
+        
+        content = '\n'.join(lines)
+        print(f"\n✓ Added DISABLE_AUTH=true to .env")
+    
+    # Write back
+    env_file.write_text(content)
+    
+    print("\n" + "=" * 70)
+    print("✅ Setup Complete!")
+    print("=" * 70)
+    
+    print("\nYour .env file now has:")
+    print("  DISABLE_AUTH=true")
+    print("\nThis means:")
+    print("  ✓ No OAuth/Google authentication needed")
+    print("  ✓ No JWT tokens required")
+    print("  ✓ Default user automatically created")
+    print("  ✓ All API endpoints work without auth headers")
+    
+    print("\nNext steps:")
+    print("  1. Start your server: uvicorn src.main:app --reload")
+    print("  2. Check status: curl http://localhost:8000/api/auth-status")
+    print("  3. Use any endpoint without authentication!")
+    
+    print("\n⚠ IMPORTANT: Never use DISABLE_AUTH=true in production!")
+    print("\nFor more info, see: docs/manuals/authentication_feature_flag.md")
+    
+
+if __name__ == "__main__":
+    try:
+        setup_no_auth()
+    except Exception as e:
+        print(f"\n✗ Error: {e}")
+        import traceback
+        traceback.print_exc()
diff --git a/src/auth/auth_service/auth_service.py b/src/auth/auth_service/auth_service.py
index c498ec1..0c530e0 100644
--- a/src/auth/auth_service/auth_service.py
+++ b/src/auth/auth_service/auth_service.py
@@ -23,8 +23,53 @@ def __init__(
         self.user_db = user_db
         self.auth_provider_factory = auth_provider_factory
         self.config = Config()
+        self._default_user = None
+        
+        # Log authentication status on startup
+        if self.config.DISABLE_AUTH:
+            logger.warning("🔓 AUTHENTICATION DISABLED - Using default user for all requests")
+        else:
+            logger.info("🔒 Authentication enabled")
 
+    def _get_or_create_default_user(self) -> User:
+        """Get or create the default user when authentication is disabled."""
+        if self._default_user is not None:
+            return self._default_user
+            
+        # Try to find existing default user
+        try:
+            user = self.user_db.get_user_by_provider_user_id("system", "default_user")
+            if user:
+                logger.info(f"Found existing default user: {user.id}")
+                self._default_user = user
+                return user
+        except Exception:
+            pass
+        
+        # Create new default user
+        user = User(
+            id=None,
+            auth_provider="system",
+            provider_user_id="default_user",
+            name="Default User",
+            email="default@local.dev",
+            picture=None,
+            owned_agents=[],
+            api_keys=[]
+        )
+        
+        saved_user = self.user_db.set_user(user)
+        logger.info(f"Created default user: {saved_user.id}")
+        self._default_user = saved_user
+        return saved_user
+    
     def login_user(self, token: str, provider: str) -> str:
+        # If authentication is disabled, return default user
+        if self.config.DISABLE_AUTH:
+            logger.info("Login bypassed - using default user")
+            user = self._get_or_create_default_user()
+            return user.id
+            
         logger.info("Logging in user")
         auth_provider: AuthProvider = self.auth_provider_factory(provider, self.user_db)
         user = auth_provider.get_authenticated_user(token)
@@ -34,6 +79,11 @@ def login_user(self, token: str, provider: str) -> str:
         return user.id
 
     def auth(self, authorize: AuthJWT | None, agent_id: str):
+        # If authentication is disabled, allow all access
+        if self.config.DISABLE_AUTH:
+            logger.debug(f"Auth check bypassed for agent {agent_id}")
+            return
+            
         if authorize is None:
             logger.warning("No authorization provided")
             raise HTTPException(status_code=401, detail="Unauthorized edit of agent")
@@ -45,6 +95,11 @@ def auth(self, authorize: AuthJWT | None, agent_id: str):
             raise HTTPException(status_code=401, detail="Unnauthorized edit of agent")
 
     def get_authenticated_user(self, authorize: AuthJWT | None) -> User:
+        # If authentication is disabled, return default user
+        if self.config.DISABLE_AUTH:
+            logger.debug("Returning default user (auth disabled)")
+            return self._get_or_create_default_user()
+            
         if authorize is None:
             logger.warning("No authorization provided")
             raise HTTPException(status_code=401, detail="Unauthorized edit of agent")
diff --git a/src/config.py b/src/config.py
index 4bc0d9d..f2dc916 100644
--- a/src/config.py
+++ b/src/config.py
@@ -75,6 +75,8 @@ def __init__(self):
         self.MONGODB_USER_COLLECTION = os.getenv("MONGODB_USER_COLLECTION", "users")
 
         ##Authentication
+        # Feature flag to disable authentication (useful for local development/testing)
+        self.DISABLE_AUTH = os.getenv("DISABLE_AUTH", "false").lower() == "true"
         self.SESSION_TOKEN_TTL = os.getenv("SESSION_TOKEN_TTL", "15")  # Minutes
         self.REFRESH_TOKEN_TTL = os.getenv("REFRESH_TOKEN_TTL", "14")  # Days
         self.JWT_TOKEN_SECRET = os.getenv(
diff --git a/src/pipeline.py b/src/pipeline.py
index a5ff0fc..25e798d 100644
--- a/src/pipeline.py
+++ b/src/pipeline.py
@@ -246,3 +246,98 @@ def chat_history_prompt_section(
         ]:  # Exclude latest user message
             chat_history += f"{msg.role.upper()}: {msg.content}\n"
     return chat_history
+
+
+
+def main():
+    """Run the RAG pipeline end-to-end with example data.
+    
+    This demonstrates how to:
+    1. Create a Command with chat history
+    2. Load an Agent configuration
+    3. Run the pipeline to generate a response with RAG context
+    """
+    import json
+    from src.models.chat.message import Message
+    from src.rag_service.dao.agent_dao import AgentDAO
+    
+    # Example: Create a sample command with chat history
+    sample_command = Command(
+        chat_log=[
+            Message(role="user", content="Hello, can you help me understand machine learning?"),
+            Message(role="assistant", content="Of course! I'd be happy to help you understand machine learning. What specific aspect would you like to learn about?"),
+            Message(role="user", content="What is supervised learning?"),
+        ],
+        agent_id="your_agent_id_here", 
+        active_role_id="user",  # Replace with actual role name
+        access_key=None,  # Optional: provide access key if required
+    )
+    
+    # Example: Load agent from database
+    # In a real scenario, you would fetch the agent from MongoDB
+    try:
+        agent_dao = AgentDAO()
+        agent = agent_dao.get_agent_by_id(sample_command.agent_id)
+        
+        if not agent:
+            print(f"Agent with ID {sample_command.agent_id} not found.")
+            print("\nTo run this pipeline, you need to:")
+            print("1. Create an agent in the database")
+            print("2. Upload documents to the agent's knowledge base")
+            print("3. Update the agent_id and active_role_id in this function")
+            return
+        
+        # Run the pipeline
+        print("=" * 80)
+        print("Running RAG Pipeline")
+        print("=" * 80)
+        print(f"Agent: {agent.name}")
+        print(f"Active Role: {sample_command.active_role_id}")
+        print(f"Chat History Length: {len(sample_command.chat_log)}")
+        print("-" * 80)
+        
+        result = assemble_prompt_with_agent(sample_command, agent)
+        
+        print("\n" + "=" * 80)
+        print("PIPELINE RESULTS")
+        print("=" * 80)
+        print(f"\nResponse ID: {result['id']}")
+        print(f"Model: {result['model']}")
+        print(f"Agent: {result['metadata']['agent_name']}")
+        print(f"Contexts Retrieved: {result['metadata']['num_context_retrieved']}")
+        print(f"Response Length: {result['metadata']['response_length']} characters")
+        
+        if result['context_used']:
+            print(f"\n--- Retrieved Contexts ({len(result['context_used'])}) ---")
+            for idx, ctx in enumerate(result['context_used'], 1):
+                print(f"\n[Context {idx}] Document: {ctx['document_name']}, Chunk: {ctx['chunk_index']}")
+                print(f"Content: {ctx['content'][:200]}...")
+        
+        if result['function_call']:
+            print(f"\n--- Function Call ---")
+            print(f"Function: {result['function_call']['function_name']}")
+            print(f"Parameters: {result['function_call']['function_parameters']}")
+        
+        print(f"\n--- Generated Response ---")
+        print(result['response'])
+        print("\n" + "=" * 80)
+        
+        
+    except Exception as e:
+        print(f"Error running pipeline: {e}")
+        import traceback
+        traceback.print_exc()
+        
+        print("\n" + "=" * 80)
+        print("TROUBLESHOOTING")
+        print("=" * 80)
+        print("Common issues:")
+        print("1. Agent ID not found - verify the agent exists in MongoDB")
+        print("2. Role ID invalid - check that the role exists in the agent configuration")
+        print("3. Database connection - ensure MongoDB is running and accessible")
+        print("4. API keys - verify LLM and embedding API keys are configured")
+        print("5. Documents - ensure documents are uploaded to the agent's knowledge base")
+
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/src/rag_service/dao/context/mongodb_context_dao.py b/src/rag_service/dao/context/mongodb_context_dao.py
index e878161..6c92a90 100644
--- a/src/rag_service/dao/context/mongodb_context_dao.py
+++ b/src/rag_service/dao/context/mongodb_context_dao.py
@@ -99,6 +99,74 @@ def __init__(self):
         # Create indexes for efficient querying
         self._create_indexes()
 
+    def _resolve_document_identifiers(
+        self, identifiers: list[str] | None, agent_id: str
+    ) -> list[str] | None:
+        """Resolve document identifiers (names or IDs) to document IDs.
+        
+        Detects if identifiers contain filenames (by checking for file extensions)
+        and resolves them to document IDs by querying the document DAO.
+        
+        Args:
+            identifiers: List of document IDs or filenames, or None for all documents
+            agent_id: Agent identifier for scoping document lookup
+            
+        Returns:
+            List of resolved document IDs, or None if no filtering requested
+        """
+        if identifiers is None:
+            return None
+            
+        if len(identifiers) == 0:
+            return []
+        
+        # Common file extensions to detect filenames
+        file_extensions = {
+            '.pdf', '.txt', '.doc', '.docx', '.md', '.csv', '.json', '.xml',
+            '.html', '.htm', '.rtf', '.odt', '.tex', '.log', '.rst'
+        }
+        
+        # Check if any identifier looks like a filename
+        potential_filenames = []
+        confirmed_ids = []
+        
+        for identifier in identifiers:
+            # Check if identifier has a file extension
+            has_extension = any(identifier.lower().endswith(ext) for ext in file_extensions)
+            
+            if has_extension:
+                potential_filenames.append(identifier)
+                logger.debug(f"Detected potential filename: {identifier}")
+            else:
+                confirmed_ids.append(identifier)
+                logger.debug(f"Treating as document ID: {identifier}")
+        
+        # If we found potential filenames, resolve them to IDs
+        if potential_filenames:
+            from src.rag_service.dao.factory import get_document_dao
+            
+            doc_dao = get_document_dao()
+            resolved_docs = doc_dao.get_by_names_and_agent(potential_filenames, agent_id)
+            
+            resolved_ids = [doc.id for doc in resolved_docs]
+            logger.info(
+                f"Resolved {len(resolved_ids)} document IDs from {len(potential_filenames)} filenames"
+            )
+            
+            # Log any filenames that couldn't be resolved
+            resolved_names = {doc.name for doc in resolved_docs}
+            unresolved = set(potential_filenames) - resolved_names
+            if unresolved:
+                logger.warning(
+                    f"Could not resolve filenames to documents: {', '.join(unresolved)}"
+                )
+            
+            # Combine resolved IDs with confirmed IDs
+            return confirmed_ids + resolved_ids
+        
+        # No filenames detected, return as-is
+        return confirmed_ids
+
     def _create_indexes(self):
         """Create database indexes for optimized queries and vector search."""
         try:
@@ -278,12 +346,17 @@ def get_context_for_agent(
         Raises:
             ValueError: If agent_id or embedding is empty
         """
-        available_documents = documents if documents is not None else []
+        # Resolve document names to IDs if filenames are provided
+        resolved_document_ids = self._resolve_document_identifiers(
+            documents, agent_id
+        )
+        
+        available_documents = resolved_document_ids if resolved_document_ids is not None else []
         # If an explicit empty list of documents is provided, there are no
         # accessible documents for this agent. Returning early avoids
         # constructing MongoDB queries like {"document_id": {"$in": []}}
         # which cause an OperationFailure in some MongoDB versions.
-        if documents is not None and len(documents) == 0:
+        if resolved_document_ids is not None and len(resolved_document_ids) == 0:
             return []
         if not agent_id:
             raise ValueError("agent_id cannot be empty")
diff --git a/src/rag_service/dao/document/base.py b/src/rag_service/dao/document/base.py
index a54f249..f86a1a5 100644
--- a/src/rag_service/dao/document/base.py
+++ b/src/rag_service/dao/document/base.py
@@ -86,6 +86,18 @@ def get_by_name_and_agent(self, name: str, agent_id: str) -> Document | None:
             Document | None: Document if found, None otherwise
         """
 
+    @abstractmethod
+    def get_by_names_and_agent(self, names: list[str], agent_id: str) -> list[Document]:
+        """Find multiple documents by names within a specific agent.
+
+        Args:
+            names (list[str]): List of document names to find
+            agent_id (str): Agent identifier
+
+        Returns:
+            list[Document]: List of matching documents (may be fewer than requested names)
+        """
+
     @abstractmethod
     def is_reachable(self) -> bool:
         """Check if the DAO backend is accessible.
diff --git a/src/rag_service/dao/document/mongodb_document_dao.py b/src/rag_service/dao/document/mongodb_document_dao.py
index a261dce..a66ec2f 100644
--- a/src/rag_service/dao/document/mongodb_document_dao.py
+++ b/src/rag_service/dao/document/mongodb_document_dao.py
@@ -229,6 +229,22 @@ def get_by_name_and_agent(self, name: str, agent_id: str) -> Document | None:
 
         return self._doc_from_mongo(doc)
 
+    def get_by_names_and_agent(self, names: list[str], agent_id: str) -> list[Document]:
+        """Find multiple documents by names within a specific agent.
+
+        Args:
+            names (list[str]): List of document names to find
+            agent_id (str): Agent identifier
+
+        Returns:
+            list[Document]: List of matching documents (may be fewer than requested names)
+        """
+        if not names or not agent_id:
+            return []
+
+        cursor = self.collection.find({"name": {"$in": names}, "agent_id": agent_id})
+        return [self._doc_from_mongo(doc) for doc in cursor]
+
     def is_reachable(self) -> bool:
         """Check if the DAO backend is accessible.
 
diff --git a/src/routes/auth.py b/src/routes/auth.py
index 14d8e83..1adc379 100644
--- a/src/routes/auth.py
+++ b/src/routes/auth.py
@@ -37,6 +37,19 @@ def get_config():
 
 @router.post("/api/login")
 async def login(request: Request, authorize: Annotated[AuthJWT, Depends()] = None):
+    # If authentication is disabled, return mock tokens and default user
+    if config.DISABLE_AUTH:
+        logger.info("Login bypassed - authentication disabled")
+        user = auth_service._get_or_create_default_user()
+        return {
+            "session_token": "disabled_auth_token",
+            "refresh_token": "disabled_auth_refresh",
+            "session_token_ttl": int(config.SESSION_TOKEN_TTL) * 1000 * 60,
+            "refresh_token_ttl": int(config.REFRESH_TOKEN_TTL) * 1000 * 60 * 60 * 24,
+            "name": user.name,
+            "picture": user.picture,
+        }
+    
     body = await request.json()
     token = body.get("token")
     provider = body.get("provider")
@@ -69,6 +82,14 @@ async def login(request: Request, authorize: Annotated[AuthJWT, Depends()] = Non
 
 @router.post("/api/refresh")
 def refresh(authorize: Annotated[AuthJWT, Depends()] = None):
+    # If authentication is disabled, return mock token
+    if config.DISABLE_AUTH:
+        logger.info("🔓 Token refresh bypassed - authentication disabled")
+        return {
+            "session_token": "disabled_auth_token",
+            "session_token_ttl": config.SESSION_TOKEN_TTL,
+        }
+    
     authorize.jwt_refresh_token_required()
     user_id = authorize.get_jwt_subject()
     new_session_token = authorize.create_access_token(subject=user_id)
@@ -84,12 +105,27 @@ def refresh(authorize: Annotated[AuthJWT, Depends()] = None):
 
 @router.get("/api/logout")
 def logout(authorize: Annotated[AuthJWT, Depends()] = None):
+    # If authentication is disabled, just return success
+    if config.DISABLE_AUTH:
+        logger.info("🔓 Logout bypassed - authentication disabled")
+        return {"detail": "Logout successful (auth disabled)"}
+    
     authorize.jwt_required()
     jti = authorize.get_raw_jwt()["jti"]
     denylist.add(jti)
     return {"detail": "Tokens has been revolked"}
 
 
+@router.get("/api/auth-status")
+def auth_status():
+    """Get current authentication status."""
+    return {
+        "auth_enabled": not config.DISABLE_AUTH,
+        "auth_disabled": config.DISABLE_AUTH,
+        "message": "Authentication is disabled - using default user" if config.DISABLE_AUTH else "Authentication is enabled"
+    }
+
+
 @AuthJWT.token_in_denylist_loader
 def check_if_token_in_denylist(decrypted_token):
     jti = decrypted_token["jti"]
diff --git a/src/test_idun.py b/src/test_idun.py
new file mode 100644
index 0000000..1586266
--- /dev/null
+++ b/src/test_idun.py
@@ -0,0 +1,26 @@
+import sys
+import requests
+ 
+def chat_with_model(token,model,question):
+    url = 'https://idun-llm.hpc.ntnu.no/api/chat/completions'
+    headers = {
+        'Authorization': f'Bearer {token}',
+        'Content-Type': 'application/json'
+    }
+    data = {
+      "model": model,
+      "messages": [
+        {
+          "role": "user",
+          "content": question
+        }
+      ]
+    }
+    response = requests.post(url, headers=headers, json=data)
+    return response.json()
+ 
+my_api_key = "sk-dbc483d4e3c3479e9be50e91d190d5d9"
+my_model = "openai/gpt-oss-120b"
+my_question = "tell me about flamingos"
+answer = chat_with_model(my_api_key, my_model, my_question)
+print(answer)
\ No newline at end of file
diff --git a/stuff.md b/stuff.md
new file mode 100644
index 0000000..28dffc1
--- /dev/null
+++ b/stuff.md
@@ -0,0 +1,20 @@
+
+#  model examples 
+
+idun LLM: 'openai/gpt-oss-120b'
+provider: idun
+
+gemini LLM: 'gemini-2.0-flash-lite'
+provider: gemini
+
+gemini embeddings: "models/text-embedding-004"
+provider: gemini
+
+
+Other models by Openai, Gemini and Idun are also possible. For Idun only language models are available, as the embeddings models idun has support for was not yet implemented when we created that part of the project. 
+
+
+## IDs:
+
+Agent ID: 6932698c69151632bf86532f
+
diff --git a/temp_files/Clean Architecture A Craftsman Guide to Software Structure and Design (1).pdf b/temp_files/Clean Architecture A Craftsman Guide to Software Structure and Design (1).pdf
new file mode 100644
index 0000000..2768784
Binary files /dev/null and b/temp_files/Clean Architecture A Craftsman Guide to Software Structure and Design (1).pdf differ
diff --git a/test_auth_flag.py b/test_auth_flag.py
new file mode 100644
index 0000000..6179275
--- /dev/null
+++ b/test_auth_flag.py
@@ -0,0 +1,85 @@
+"""
+Quick test script to verify DISABLE_AUTH feature flag works correctly.
+Run this to ensure authentication bypass is functioning.
+"""
+
+import os
+import sys
+from pathlib import Path
+
+# Add src to path
+sys.path.insert(0, str(Path(__file__).parent))
+
+# Set DISABLE_AUTH before importing anything
+os.environ["DISABLE_AUTH"] = "true"
+os.environ["FERNET_KEY"] = "test_key_" + "x" * 32  # Dummy key for testing
+
+print("Testing DISABLE_AUTH feature flag...")
+print("=" * 60)
+
+try:
+    from src.config import Config
+    config = Config()
+    
+    print(f"\n✓ Config loaded")
+    print(f"  DISABLE_AUTH: {config.DISABLE_AUTH}")
+    
+    assert config.DISABLE_AUTH == True, "DISABLE_AUTH should be True"
+    print(f"  ✓ Feature flag correctly set to True")
+    
+except Exception as e:
+    print(f"\n✗ Config test failed: {e}")
+    sys.exit(1)
+
+try:
+    from src.auth.auth_service.auth_service import AuthService
+    from src.rag_service.dao.factory import get_user_dao
+    from src.auth.auth_provider.factory import auth_provider_factory
+    
+    print(f"\n✓ Auth modules imported")
+    
+    # Create auth service
+    user_dao = get_user_dao()
+    auth_service = AuthService(user_dao, auth_provider_factory)
+    
+    print(f"  ✓ AuthService created")
+    
+    # Test get_authenticated_user with None (should return default user)
+    user = auth_service.get_authenticated_user(None)
+    
+    print(f"\n✓ Default user retrieved:")
+    print(f"  Name: {user.name}")
+    print(f"  Email: {user.email}")
+    print(f"  Provider: {user.auth_provider}")
+    print(f"  ID: {user.id}")
+    
+    assert user.name == "Default User", "User should be 'Default User'"
+    assert user.email == "default@local.dev", "Email should be 'default@local.dev'"
+    assert user.auth_provider == "system", "Provider should be 'system'"
+    
+    print(f"\n✓ Default user validation passed")
+    
+except Exception as e:
+    print(f"\n✗ Auth service test failed: {e}")
+    import traceback
+    traceback.print_exc()
+    sys.exit(1)
+
+try:
+    # Test that auth bypass works
+    auth_service.auth(None, "fake_agent_id")
+    print(f"\n✓ Auth bypass works (no exception raised)")
+    
+except Exception as e:
+    print(f"\n✗ Auth bypass test failed: {e}")
+    sys.exit(1)
+
+print("\n" + "=" * 60)
+print("✅ ALL TESTS PASSED")
+print("=" * 60)
+print("\nThe DISABLE_AUTH feature flag is working correctly!")
+print("\nTo use in your application:")
+print("1. Set DISABLE_AUTH=true in your .env file")
+print("2. Restart your server")
+print("3. All authentication will be bypassed")
+print("4. Default user will be used for all requests")
diff --git a/tests/mocks/mock_context_dao.py b/tests/mocks/mock_context_dao.py
index aa8ca8b..00c6c51 100644
--- a/tests/mocks/mock_context_dao.py
+++ b/tests/mocks/mock_context_dao.py
@@ -4,11 +4,16 @@
 of a real DAO without requiring actual database connections.
 """
 
+import logging
+
 from src.rag_service.context import Context
 from src.rag_service.dao import ContextDAO
 from src.utils import singleton
 
 
+logger = logging.getLogger(__name__)
+
+
 @singleton
 class MockContextDAO(ContextDAO):
     """In-memory singleton implementation of ContextDAO for testing.
@@ -23,6 +28,21 @@ def __init__(self):
         self.similarity_threshold = 0.7
         self.collection = self  # For compatibility with code expecting .collection
 
+    def _resolve_document_identifiers(
+        self, identifiers: list[str] | None, agent_id: str
+    ) -> list[str] | None:
+        """Resolve document identifiers (names or IDs) to document IDs.
+        
+        Mock implementation that mimics the MongoDB version's behavior.
+        
+        Args:
+            identifiers: List of document IDs or filenames, or None for all documents
+            agent_id: Agent identifier for scoping document lookup
+            
+        Returns:
+            List of resolved document IDs, or None if no filtering requested
+        \"\"\"\n        if identifiers is None:\n            return None\n            \n        if len(identifiers) == 0:\n            return []\n        \n        # Common file extensions to detect filenames\n        file_extensions = {\n            '.pdf', '.txt', '.doc', '.docx', '.md', '.csv', '.json', '.xml',\n            '.html', '.htm', '.rtf', '.odt', '.tex', '.log', '.rst'\n        }\n        \n        # Check if any identifier looks like a filename\n        potential_filenames = []\n        confirmed_ids = []\n        \n        for identifier in identifiers:\n            # Check if identifier has a file extension\n            has_extension = any(identifier.lower().endswith(ext) for ext in file_extensions)\n            \n            if has_extension:\n                potential_filenames.append(identifier)\n                logger.debug(f\"Mock: Detected potential filename: {identifier}\")\n            else:\n                confirmed_ids.append(identifier)\n                logger.debug(f\"Mock: Treating as document ID: {identifier}\")\n        \n        # If we found potential filenames, resolve them to IDs\n        if potential_filenames:\n            from src.rag_service.dao.factory import get_document_dao\n            \n            doc_dao = get_document_dao()\n            resolved_docs = doc_dao.get_by_names_and_agent(potential_filenames, agent_id)\n            \n            resolved_ids = [doc.id for doc in resolved_docs]\n            logger.info(\n                f\"Mock: Resolved {len(resolved_ids)} document IDs from {len(potential_filenames)} filenames\"\n            )\n            \n            # Log any filenames that couldn't be resolved\n            resolved_names = {doc.name for doc in resolved_docs}\n            unresolved = set(potential_filenames) - resolved_names\n            if unresolved:\n                logger.warning(\n                    f\"Mock: Could not resolve filenames to documents: {', '.join(unresolved)}\"\n                )\n            \n            # Combine resolved IDs with confirmed IDs\n            return confirmed_ids + resolved_ids\n        \n        # No filenames detected, return as-is\n        return confirmed_ids
+"""
     def get_context_for_agent(
         self,
         agent_id: str,
@@ -62,6 +82,11 @@ def get_context_for_agent(
         if not query_embedding:
             raise ValueError("Embedding cannot be empty")
 
+        # Resolve document names to IDs if filenames are provided
+        resolved_document_ids = self._resolve_document_identifiers(
+            documents, agent_id
+        )
+
         # Use provided threshold or fall back to instance default
         threshold = (
             similarity_threshold
@@ -75,8 +100,8 @@ def get_context_for_agent(
             if document.get("agent_id") != agent_id:
                 continue
 
-            # Filter by documents if provided
-            if documents and document.get("_id") not in documents:
+            # Filter by documents if provided (now using resolved IDs)
+            if resolved_document_ids is not None and document.get("_id") not in resolved_document_ids:
                 continue
 
             # Mock similarity - returns high value for testing
diff --git a/tests/mocks/mock_document_dao.py b/tests/mocks/mock_document_dao.py
index 9a73dbd..a2aa436 100644
--- a/tests/mocks/mock_document_dao.py
+++ b/tests/mocks/mock_document_dao.py
@@ -147,6 +147,24 @@ def get_by_name_and_agent(self, name: str, agent_id: str) -> Document | None:
                 return doc
         return None
 
+    def get_by_names_and_agent(self, names: list[str], agent_id: str) -> list[Document]:
+        """Find multiple documents by names within a specific agent.
+
+        Args:
+            names (list[str]): List of document names to find
+            agent_id (str): Agent identifier
+
+        Returns:
+            list[Document]: List of matching documents (may be fewer than requested names)
+        """
+        if not names or not agent_id:
+            return []
+        
+        return [
+            doc for doc in self._documents.values()
+            if doc.name in names and doc.agent_id == agent_id
+        ]
+
     def is_reachable(self) -> bool:
         """Check if the DAO backend is accessible.