SheWhoReignsSupreme/claude-os
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
claude-os/mcp_server/server.py
Illya f6320faa9c fix: Fix delete document endpoint SQLite cursor handling 
- Replace context manager pattern with direct cursor assignment
  (SQLite cursors don't support context manager protocol)
- Use conn.close() instead of db_manager.return_connection()
  (SQLiteManager doesn't have return_connection method)

Fixes 500 error when deleting documents via REST API.
2025-12-08 23:54:49 -05:00

2830 lines
98 KiB
Python
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

"""
MCP Server for Claude OS.
Exposes RAG functionality via Model Context Protocol with HTTP transport.
"""
import logging
import os
import sys
from pathlib import Path
from typing import Any, Dict, List
# Add parent directory to path for imports
sys.path.insert(0, str(Path(__file__).parent.parent))
from fastapi import FastAPI, Request, UploadFile, File, HTTPException, Depends, BackgroundTasks
from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import JSONResponse
from pydantic import BaseModel
import uvicorn
import requests
from typing import Optional
from slowapi import Limiter, _rate_limit_exceeded_handler
from slowapi.util import get_remote_address
from slowapi.errors import RateLimitExceeded
from app.core.sqlite_manager import get_sqlite_manager
from app.core.config import Config
from app.core.kb_metadata import get_collection_stats, get_documents_metadata
from app.core.kb_types import KBType
from app.core.rag_engine import RAGEngine
from app.core.agent_os_ingestion import AgentOSIngestion
from app.core.agent_os_parser import AgentOSContentType
from app.core.hooks import get_project_hook
from app.core.file_watcher import get_global_watcher
from app.core.spec_manager import SpecManager
from functools import lru_cache
import time
from threading import Lock
# Configure logging
logging.basicConfig(
level=logging.INFO,
format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
)
logger = logging.getLogger(__name__)
# RAGEngine cache with TTL - Optimized for M4 Pro with 48GB RAM
RAG_ENGINE_CACHE = {}
RAG_ENGINE_CACHE_LOCK = Lock()
RAG_ENGINE_CACHE_TTL = 3600 # 1 hour TTL with plenty of RAM
# Background job status tracking for long-running operations
INDEXING_JOBS = {} # job_id -> {status, progress, message, started_at, completed_at, error}
INDEXING_JOBS_LOCK = Lock()
MAX_STORED_JOBS = 100 # Limit stored jobs to prevent memory leak
JOB_RETENTION_SECONDS = 3600 * 24 # Keep completed jobs for 24 hours
def _cleanup_old_jobs():
"""Remove old completed jobs to prevent memory leak."""
with INDEXING_JOBS_LOCK:
if len(INDEXING_JOBS) <= MAX_STORED_JOBS:
return
current_time = time.time()
# Find jobs to remove (completed/failed and older than retention period)
jobs_to_remove = []
for job_id, job in INDEXING_JOBS.items():
if job["status"] in ["completed", "failed"]:
completed_at = job.get("completed_at", job.get("started_at", 0))
if current_time - completed_at > JOB_RETENTION_SECONDS:
jobs_to_remove.append(job_id)
# If still over limit, remove oldest completed jobs
if len(INDEXING_JOBS) - len(jobs_to_remove) > MAX_STORED_JOBS:
completed_jobs = [
(jid, j) for jid, j in INDEXING_JOBS.items()
if j["status"] in ["completed", "failed"] and jid not in jobs_to_remove
]
completed_jobs.sort(key=lambda x: x[1].get("completed_at", 0))
excess = len(INDEXING_JOBS) - len(jobs_to_remove) - MAX_STORED_JOBS
for jid, _ in completed_jobs[:excess]:
jobs_to_remove.append(jid)
for job_id in jobs_to_remove:
del INDEXING_JOBS[job_id]
if jobs_to_remove:
logger.debug(f"Cleaned up {len(jobs_to_remove)} old indexing jobs")
# Initialize FastAPI
app = FastAPI(title="Claude OS MCP Server")
# Add CORS middleware with security-conscious defaults
# In production, set ALLOWED_ORIGINS env var to your specific domains
allowed_origins_str = os.getenv(
"ALLOWED_ORIGINS",
"http://localhost:5173,http://localhost:8051,http://127.0.0.1:5173,http://127.0.0.1:8051"
)
allowed_origins = [origin.strip() for origin in allowed_origins_str.split(",") if origin.strip()]
app.add_middleware(
CORSMiddleware,
allow_origins=allowed_origins, # Restricted to specific origins for security
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
# Initialize rate limiter
limiter = Limiter(key_func=get_remote_address)
app.state.limiter = limiter
app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
def get_cached_rag_engine(kb_name: str) -> RAGEngine:
"""
Get or create a cached RAGEngine instance.
Implements singleton pattern with TTL to avoid recreating engines for every query.
Args:
kb_name: Name of the knowledge base
Returns:
Cached or new RAGEngine instance
"""
global RAG_ENGINE_CACHE
with RAG_ENGINE_CACHE_LOCK:
current_time = time.time()
# Check if engine exists and is not expired
if kb_name in RAG_ENGINE_CACHE:
engine, timestamp = RAG_ENGINE_CACHE[kb_name]
if current_time - timestamp < RAG_ENGINE_CACHE_TTL:
logger.info(f"Using cached RAGEngine for {kb_name} (age: {current_time - timestamp:.1f}s)")
return engine
else:
logger.info(f"RAGEngine cache expired for {kb_name}, creating new instance")
del RAG_ENGINE_CACHE[kb_name]
# Create new engine
logger.info(f"Creating new RAGEngine for {kb_name}")
start_time = time.time()
engine = RAGEngine(kb_name)
creation_time = time.time() - start_time
logger.info(f"RAGEngine created for {kb_name} in {creation_time:.2f}s")
# Cache the engine
RAG_ENGINE_CACHE[kb_name] = (engine, current_time)
# Clean up old entries (keep max 50 engines in cache with 48GB RAM)
if len(RAG_ENGINE_CACHE) > 50:
oldest_kb = min(RAG_ENGINE_CACHE.items(), key=lambda x: x[1][1])[0]
del RAG_ENGINE_CACHE[oldest_kb]
logger.info(f"Evicted oldest RAGEngine from cache: {oldest_kb}")
return engine
# MCP Tools Registry
TOOLS = {
"search_knowledge_base": {
"description": "Search a knowledge base using RAG with optional advanced features",
"inputSchema": {
"type": "object",
"properties": {
"kb_name": {"type": "string", "description": "Name of the knowledge base to search"},
"query": {"type": "string", "description": "The search query"},
"use_hybrid": {"type": "boolean", "description": "Enable hybrid search (vector + BM25)", "default": False},
"use_rerank": {"type": "boolean", "description": "Enable reranking for better relevance", "default": False},
"use_agentic": {"type": "boolean", "description": "Enable agentic RAG for complex queries", "default": False}
},
"required": ["kb_name", "query"]
}
},
"list_knowledge_bases": {
"description": "List all available knowledge bases with type metadata",
"inputSchema": {
"type": "object",
"properties": {}
}
},
"list_knowledge_bases_by_type": {
"description": "List knowledge bases filtered by type (e.g., agent-os, code, documentation)",
"inputSchema": {
"type": "object",
"properties": {
"kb_type": {
"type": "string",
"description": "KB type to filter by",
"enum": ["generic", "code", "documentation", "agent-os"]
}
},
"required": ["kb_type"]
}
},
"create_knowledge_base": {
"description": "Create a new knowledge base with specified type",
"inputSchema": {
"type": "object",
"properties": {
"name": {"type": "string", "description": "Name for the new knowledge base"},
"kb_type": {
"type": "string",
"description": "Type of knowledge base",
"enum": ["generic", "code", "documentation", "agent-os"],
"default": "generic"
},
"description": {"type": "string", "description": "Optional description", "default": ""}
},
"required": ["name"]
}
},
"get_kb_stats": {
"description": "Get statistics for a knowledge base",
"inputSchema": {
"type": "object",
"properties": {
"kb_name": {"type": "string", "description": "Name of the knowledge base"}
},
"required": ["kb_name"]
}
},
"list_documents": {
"description": "List all documents in a knowledge base",
"inputSchema": {
"type": "object",
"properties": {
"kb_name": {"type": "string", "description": "Name of the knowledge base"}
},
"required": ["kb_name"]
}
},
"ingest_agent_os_profile": {
"description": "Ingest an Agent OS profile directory into a knowledge base",
"inputSchema": {
"type": "object",
"properties": {
"kb_name": {"type": "string", "description": "Name of the Agent OS knowledge base"},
"profile_path": {"type": "string", "description": "Path to the Agent OS profile directory"}
},
"required": ["kb_name", "profile_path"]
}
},
"get_agent_os_stats": {
"description": "Get statistics about Agent OS content in a knowledge base",
"inputSchema": {
"type": "object",
"properties": {
"kb_name": {"type": "string", "description": "Name of the Agent OS knowledge base"}
},
"required": ["kb_name"]
}
},
"get_standards": {
"description": "Get coding standards from an Agent OS knowledge base",
"inputSchema": {
"type": "object",
"properties": {
"kb_name": {"type": "string", "description": "Name of the Agent OS knowledge base"},
"query": {"type": "string", "description": "Optional search query to filter standards", "default": ""}
},
"required": ["kb_name"]
}
},
"get_workflows": {
"description": "Get development workflows from an Agent OS knowledge base",
"inputSchema": {
"type": "object",
"properties": {
"kb_name": {"type": "string", "description": "Name of the Agent OS knowledge base"},
"query": {"type": "string", "description": "Optional search query to filter workflows", "default": ""}
},
"required": ["kb_name"]
}
},
"get_specs": {
"description": "Get feature specifications from an Agent OS knowledge base",
"inputSchema": {
"type": "object",
"properties": {
"kb_name": {"type": "string", "description": "Name of the Agent OS knowledge base"},
"query": {"type": "string", "description": "Optional search query to filter specs", "default": ""}
},
"required": ["kb_name"]
}
},
"get_product_context": {
"description": "Get product vision and context from an Agent OS knowledge base",
"inputSchema": {
"type": "object",
"properties": {
"kb_name": {"type": "string", "description": "Name of the Agent OS knowledge base"}
},
"required": ["kb_name"]
}
}
}
# Tool implementation functions
async def search_knowledge_base(kb_name: str, query: str, use_hybrid: bool = False,
use_rerank: bool = False, use_agentic: bool = False) -> dict:
"""Search a knowledge base using RAG with cached engine for performance."""
try:
start_time = time.time()
db_manager = get_sqlite_manager()
if not db_manager.collection_exists(kb_name):
return {"error": f"Knowledge base '{kb_name}' not found", "answer": "", "sources": []}
count = db_manager.get_collection_count(kb_name)
if count == 0:
return {"error": f"Knowledge base '{kb_name}' is empty", "answer": "", "sources": []}
# Use cached RAGEngine instance instead of creating new one
rag_engine = get_cached_rag_engine(kb_name)
query_start = time.time()
result = rag_engine.query(question=query, use_hybrid=use_hybrid,
use_rerank=use_rerank, use_agentic=use_agentic)
query_time = time.time() - query_start
total_time = time.time() - start_time
logger.info(f"Query executed on {kb_name}: {query[:50]}... (total: {total_time:.2f}s, query: {query_time:.2f}s)")
# Add timing info to result for debugging
result['_timing'] = {
'total_time': total_time,
'query_time': query_time
}
return result
except Exception as e:
logger.error(f"Search failed: {e}")
return {"error": str(e), "answer": "", "sources": []}
async def list_knowledge_bases() -> List[Dict[str, any]]:
"""List all available knowledge bases with metadata."""
try:
db_manager = get_sqlite_manager()
kbs = db_manager.list_collections()
logger.info(f"Listed {len(kbs)} knowledge bases")
return kbs
except Exception as e:
logger.error(f"Failed to list knowledge bases: {e}")
return []
async def get_kb_stats(kb_name: str) -> dict:
"""Get statistics for a knowledge base."""
try:
stats = get_collection_stats(kb_name)
logger.info(f"Retrieved stats for {kb_name}")
return stats
except Exception as e:
logger.error(f"Failed to get stats for {kb_name}: {e}")
return {"error": str(e), "total_documents": 0, "total_chunks": 0, "last_updated": None}
async def list_documents(kb_name: str) -> List[dict]:
"""List all documents in a knowledge base."""
try:
docs = get_documents_metadata(kb_name)
logger.info(f"Listed {len(docs)} documents in {kb_name}")
return docs
except Exception as e:
logger.error(f"Failed to list documents in {kb_name}: {e}")
return []
async def list_knowledge_bases_by_type(kb_type: str) -> List[Dict[str, any]]:
"""List knowledge bases filtered by type."""
try:
db_manager = get_sqlite_manager()
kb_type_enum = KBType(kb_type)
kbs = db_manager.list_collections_by_type(kb_type_enum)
logger.info(f"Listed {len(kbs)} knowledge bases of type {kb_type}")
return kbs
except Exception as e:
logger.error(f"Failed to list knowledge bases by type {kb_type}: {e}")
return []
async def create_knowledge_base(name: str, kb_type: str = "generic", description: str = "") -> dict:
"""Create a new knowledge base."""
try:
db_manager = get_sqlite_manager()
# Check if already exists
if db_manager.collection_exists(name):
return {
"success": False,
"error": f"Knowledge base '{name}' already exists"
}
# Create collection
kb_type_enum = KBType(kb_type)
success = db_manager.create_collection(
name=name,
kb_type=kb_type_enum,
description=description
)
if success:
logger.info(f"Created knowledge base: {name} (type: {kb_type})")
return {
"success": True,
"name": name,
"kb_type": kb_type,
"description": description
}
else:
return {
"success": False,
"error": "Failed to create knowledge base"
}
except Exception as e:
logger.error(f"Failed to create knowledge base {name}: {e}")
return {
"success": False,
"error": str(e)
}
async def ingest_agent_os_profile(kb_name: str, profile_path: str) -> dict:
"""Ingest an Agent OS profile into a knowledge base."""
try:
db_manager = get_sqlite_manager()
agent_os_ingestion = AgentOSIngestion(db_manager)
stats = agent_os_ingestion.ingest_profile(
kb_name=kb_name,
profile_path=profile_path
)
logger.info(f"Ingested Agent OS profile from {profile_path} into {kb_name}")
return stats
except Exception as e:
logger.error(f"Failed to ingest Agent OS profile: {e}")
return {
"success": False,
"error": str(e),
"documents_processed": 0
}
async def get_agent_os_stats(kb_name: str) -> dict:
"""Get statistics about Agent OS content in a knowledge base."""
try:
db_manager = get_sqlite_manager()
agent_os_ingestion = AgentOSIngestion(db_manager)
stats = agent_os_ingestion.get_profile_stats(kb_name)
logger.info(f"Retrieved Agent OS stats for {kb_name}")
return stats
except Exception as e:
logger.error(f"Failed to get Agent OS stats for {kb_name}: {e}")
return {
"total_documents": 0,
"documents_by_type": {},
"error": str(e)
}
async def get_standards(kb_name: str, query: str = "") -> List[dict]:
"""Get coding standards from an Agent OS knowledge base."""
try:
db_manager = get_sqlite_manager()
agent_os_ingestion = AgentOSIngestion(db_manager)
results = agent_os_ingestion.search_by_type(
kb_name=kb_name,
content_type=AgentOSContentType.STANDARD,
query=query if query else None,
limit=20
)
logger.info(f"Retrieved {len(results)} standards from {kb_name}")
return results
except Exception as e:
logger.error(f"Failed to get standards from {kb_name}: {e}")
return []
async def get_workflows(kb_name: str, query: str = "") -> List[dict]:
"""Get development workflows from an Agent OS knowledge base."""
try:
db_manager = get_sqlite_manager()
agent_os_ingestion = AgentOSIngestion(db_manager)
results = agent_os_ingestion.search_by_type(
kb_name=kb_name,
content_type=AgentOSContentType.WORKFLOW,
query=query if query else None,
limit=20
)
logger.info(f"Retrieved {len(results)} workflows from {kb_name}")
return results
except Exception as e:
logger.error(f"Failed to get workflows from {kb_name}: {e}")
return []
async def get_specs(kb_name: str, query: str = "") -> List[dict]:
"""Get feature specifications from an Agent OS knowledge base."""
try:
db_manager = get_sqlite_manager()
agent_os_ingestion = AgentOSIngestion(db_manager)
results = agent_os_ingestion.search_by_type(
kb_name=kb_name,
content_type=AgentOSContentType.SPEC,
query=query if query else None,
limit=20
)
logger.info(f"Retrieved {len(results)} specs from {kb_name}")
return results
except Exception as e:
logger.error(f"Failed to get specs from {kb_name}: {e}")
return []
async def get_product_context(kb_name: str) -> List[dict]:
"""Get product vision and context from an Agent OS knowledge base."""
try:
db_manager = get_sqlite_manager()
agent_os_ingestion = AgentOSIngestion(db_manager)
results = agent_os_ingestion.search_by_type(
kb_name=kb_name,
content_type=AgentOSContentType.PRODUCT,
query=None,
limit=20
)
logger.info(f"Retrieved {len(results)} product context documents from {kb_name}")
return results
except Exception as e:
logger.error(f"Failed to get product context from {kb_name}: {e}")
return []
# Pydantic models for REST API
class CreateKBRequest(BaseModel):
name: str
kb_type: str = "generic"
description: str = ""
class ChatRequest(BaseModel):
query: str
use_hybrid: bool = False
use_rerank: bool = False
use_agentic: bool = False
# REST API Endpoints for UI
@app.get("/api/kb")
async def api_list_knowledge_bases():
"""REST API: List all knowledge bases."""
kbs = await list_knowledge_bases()
return {"knowledge_bases": kbs}
@app.post("/api/kb")
async def api_create_knowledge_base(request: CreateKBRequest):
"""REST API: Create a new knowledge base."""
result = await create_knowledge_base(
name=request.name,
kb_type=request.kb_type,
description=request.description
)
if not result.get("success"):
raise HTTPException(status_code=400, detail=result.get("error"))
return result
@app.delete("/api/kb/{kb_name}")
async def api_delete_knowledge_base(kb_name: str):
"""REST API: Delete a knowledge base."""
try:
db_manager = get_sqlite_manager()
if not db_manager.collection_exists(kb_name):
raise HTTPException(status_code=404, detail=f"Knowledge base '{kb_name}' not found")
success = db_manager.delete_collection(kb_name)
if success:
return {"success": True, "message": f"Knowledge base '{kb_name}' deleted"}
else:
raise HTTPException(status_code=500, detail="Failed to delete knowledge base")
except HTTPException:
raise
except Exception as e:
logger.error(f"Failed to delete KB {kb_name}: {e}")
raise HTTPException(status_code=500, detail=str(e))
@app.get("/api/kb/{kb_name}/stats")
async def api_get_kb_stats(kb_name: str):
"""REST API: Get knowledge base statistics."""
stats = await get_kb_stats(kb_name)
if "error" in stats:
raise HTTPException(status_code=404, detail=stats["error"])
return stats
@app.get("/api/kb/{kb_name}/documents")
async def api_list_documents(kb_name: str):
"""REST API: List documents in a knowledge base."""
docs = await list_documents(kb_name)
return {"documents": docs}
@app.post("/api/kb/{kb_name}/chat")
@limiter.limit("20/minute") # Rate limit: 20 queries per minute per IP
async def api_chat(request: Request, kb_name: str, chat_request: ChatRequest):
"""REST API: Chat with a knowledge base."""
result = await search_knowledge_base(
kb_name=kb_name,
query=chat_request.query,
use_hybrid=chat_request.use_hybrid,
use_rerank=chat_request.use_rerank,
use_agentic=chat_request.use_agentic
)
if "error" in result and result["error"]:
raise HTTPException(status_code=400, detail=result["error"])
return result
@app.post("/api/kb/{kb_name}/upload")
async def api_upload_document(kb_name: str, file: UploadFile = File(...)):
"""REST API: Upload a single document to a knowledge base."""
import tempfile
import os
from app.core.ingestion import ingest_file
# Validate KB exists
db_manager = get_sqlite_manager()
if not db_manager.collection_exists(kb_name):
raise HTTPException(status_code=404, detail=f"Knowledge base '{kb_name}' not found")
# Save uploaded file to temp location
try:
with tempfile.NamedTemporaryFile(delete=False, suffix=Path(file.filename).suffix) as tmp_file:
content = await file.read()
tmp_file.write(content)
tmp_path = tmp_file.name
# Ingest the file
result = ingest_file(tmp_path, kb_name, file.filename)
# Clean up temp file
os.unlink(tmp_path)
if result["status"] == "error":
raise HTTPException(status_code=400, detail=result.get("error", "Upload failed"))
return {
"success": True,
"filename": result["filename"],
"chunks": result["chunks"],
"file_type": result["file_type"]
}
except HTTPException:
raise
except Exception as e:
logger.error(f"Upload failed: {e}")
raise HTTPException(status_code=500, detail=str(e))
@app.post("/api/kb/{kb_name}/import")
async def api_import_directory(kb_name: str, directory_path: str):
"""REST API: Import all files from a directory into a knowledge base."""
from app.core.ingestion import ingest_directory
# Validate KB exists
db_manager = get_sqlite_manager()
if not db_manager.collection_exists(kb_name):
raise HTTPException(status_code=404, detail=f"Knowledge base '{kb_name}' not found")
# Validate directory exists
if not Path(directory_path).exists():
raise HTTPException(status_code=404, detail=f"Directory not found: {directory_path}")
try:
results = ingest_directory(directory_path, kb_name)
# Count successes and failures
successes = [r for r in results if r.get("status") == "success"]
failures = [r for r in results if r.get("status") == "error"]
return {
"success": True,
"total_files": len(results),
"successful": len(successes),
"failed": len(failures),
"results": results
}
except Exception as e:
logger.error(f"Directory import failed: {e}")
raise HTTPException(status_code=500, detail=str(e))
@app.delete("/api/kb/{kb_name}/documents/{filename}")
async def api_delete_document(kb_name: str, filename: str):
"""REST API: Delete a document from a knowledge base by filename."""
db_manager = get_sqlite_manager()
# Validate KB exists
if not db_manager.collection_exists(kb_name):
raise HTTPException(status_code=404, detail=f"Knowledge base '{kb_name}' not found")
try:
# Get the collection ID
conn = db_manager.get_connection()
try:
cursor = conn.cursor()
# Get collection ID
cursor.execute(
"SELECT id FROM knowledge_bases WHERE name = ?",
(kb_name,)
)
result = cursor.fetchone()
if not result:
raise HTTPException(status_code=404, detail=f"Knowledge base '{kb_name}' not found")
collection_id = result[0]
# Delete documents with this filename
cursor.execute(
"""
DELETE FROM documents
WHERE kb_id = ? AND json_extract(metadata, '$.filename') = ?
RETURNING id
""",
(collection_id, filename)
)
deleted_count = len(cursor.fetchall())
conn.commit()
if deleted_count == 0:
raise HTTPException(status_code=404, detail=f"No documents found with filename '{filename}'")
logger.info(f"Deleted {deleted_count} document(s) with filename '{filename}' from KB '{kb_name}'")
return {
"success": True,
"message": f"Deleted {deleted_count} document(s)",
"filename": filename,
"kb_name": kb_name
}
finally:
conn.close()
except HTTPException:
raise
except Exception as e:
logger.error(f"Failed to delete document: {e}")
raise HTTPException(status_code=500, detail=str(e))
# ============================================================================
# HYBRID INDEXING ENDPOINTS (NEW - Tree-sitter structural indexing)
# ============================================================================
class StructuralIndexRequest(BaseModel):
"""Request model for structural indexing."""
project_path: str
cache_path: Optional[str] = None
token_budget: int = 1024
class SemanticIndexRequest(BaseModel):
"""Request model for semantic indexing."""
project_path: str
selective: bool = True # Only index top 20% + docs
personalization: Optional[Dict[str, float]] = None
background: bool = True # Run in background (True) or sync/blocking (False)
@app.post("/api/kb/{kb_name}/index-structural")
async def api_index_structural(kb_name: str, request: StructuralIndexRequest):
"""
REST API: Fast structural indexing using tree-sitter.
Phase 1 of hybrid indexing - completes in ~30 seconds for 10k files.
"""
from app.core.tree_sitter_indexer import TreeSitterIndexer
import json
# Validate KB exists
db_manager = get_sqlite_manager()
if not db_manager.collection_exists(kb_name):
raise HTTPException(status_code=404, detail=f"Knowledge base '{kb_name}' not found")
# Validate project path
if not Path(request.project_path).exists():
raise HTTPException(status_code=404, detail=f"Project path not found: {request.project_path}")
try:
logger.info(f"Starting structural indexing for {kb_name} at {request.project_path}")
start_time = time.time()
# Create indexer with cache
cache_path = request.cache_path or str(Path(request.project_path) / ".claude-os" / "tree_sitter_cache.db")
indexer = TreeSitterIndexer(cache_path)
# Index the directory
repo_map = indexer.index_directory(
request.project_path,
personalization=None,
token_budget=request.token_budget
)
# Store repo map as JSON document directly (NO EMBEDDING!)
repo_map_json = json.dumps(repo_map.to_dict(), indent=2)
# Store directly in database without embedding - use raw SQL
conn = db_manager.get_connection()
cursor = conn.cursor()
# Get KB ID
cursor.execute("SELECT id FROM knowledge_bases WHERE name = ?", (kb_name,))
kb_result = cursor.fetchone()
if not kb_result:
raise HTTPException(status_code=404, detail=f"Knowledge base '{kb_name}' not found")
kb_id = kb_result['id']
# Insert or replace the repo map document
metadata_json = json.dumps({
"filename": "repo_map.json",
"type": "structural_index",
"total_files": repo_map.total_files,
"total_symbols": repo_map.total_symbols,
"indexed_at": time.time(),
"kb_id": str(kb_id)
})
# Check if document already exists
cursor.execute(
"SELECT id FROM documents WHERE kb_id = ? AND doc_id = ?",
(kb_id, "repo_map")
)
existing = cursor.fetchone()
if existing:
# Update existing
cursor.execute(
"""UPDATE documents
SET content = ?, metadata = ?
WHERE kb_id = ? AND doc_id = ?""",
(repo_map_json, metadata_json, kb_id, "repo_map")
)
else:
# Insert new
cursor.execute(
"""INSERT INTO documents
(kb_id, doc_id, content, metadata)
VALUES (?, ?, ?, ?)""",
(kb_id, "repo_map", repo_map_json, metadata_json)
)
conn.commit()
# Close indexer
indexer.close()
elapsed = time.time() - start_time
logger.info(f"Structural indexing complete for {kb_name} in {elapsed:.1f}s")
return {
"success": True,
"kb_name": kb_name,
"total_files": repo_map.total_files,
"total_symbols": repo_map.total_symbols,
"time_taken_seconds": elapsed,
"repo_map_preview": indexer.generate_repo_map(repo_map.tags[:50], token_budget=512),
"message": f"Structural index created: {repo_map.total_symbols} symbols in {repo_map.total_files} files"
}
except Exception as e:
logger.error(f"Structural indexing failed: {e}")
raise HTTPException(status_code=500, detail=str(e))
def _run_semantic_indexing_background(job_id: str, kb_name: str, project_path: str, selective: bool, personalization: dict = None):
"""
Background worker for semantic indexing. Runs in a separate thread to avoid blocking.
Updates INDEXING_JOBS with progress.
"""
from app.core.tree_sitter_indexer import TreeSitterIndexer
from app.core.ingestion import ingest_directory, ingest_file
def update_job(status: str, progress: int = 0, message: str = "", error: str = None):
with INDEXING_JOBS_LOCK:
INDEXING_JOBS[job_id].update({
"status": status,
"progress": progress,
"message": message,
"error": error,
"updated_at": time.time()
})
if status in ["completed", "failed"]:
INDEXING_JOBS[job_id]["completed_at"] = time.time()
try:
logger.info(f"[Job {job_id}] Starting semantic indexing for {kb_name} at {project_path}")
start_time = time.time()
update_job("running", 0, "Starting indexing...")
if selective:
# Load repo map if exists
cache_path = str(Path(project_path) / ".claude-os" / "tree_sitter_cache.db")
update_job("running", 5, "Loading structural index...")
indexer = TreeSitterIndexer(cache_path)
repo_map = indexer.index_directory(project_path, personalization)
indexer.close()
# Select top 20% files by importance
top_20_percent = max(1, int(len(repo_map.tags) * 0.2))
important_tags = repo_map.tags[:top_20_percent]
important_files = list(set(tag.file for tag in important_tags))
# Add all documentation files
docs_patterns = ["*.md", "*.txt", "*.rst"]
doc_files = []
for pattern in docs_patterns:
doc_files.extend(Path(project_path).rglob(pattern))
all_files = list(set(important_files + [str(f.relative_to(project_path)) for f in doc_files]))
total_files = len(all_files)
update_job("running", 10, f"Found {total_files} files to index (top 20% + docs)")
logger.info(f"[Job {job_id}] Selective indexing: {total_files} files")
# Ingest selected files only
results = []
for i, file_rel_path in enumerate(all_files):
file_path = Path(project_path) / file_rel_path
if file_path.exists() and file_path.is_file():
try:
result = ingest_file(str(file_path), kb_name, str(file_rel_path))
results.append({"status": "success", "file": str(file_rel_path)})
logger.debug(f"[Job {job_id}] Ingested: {file_rel_path}")
except Exception as e:
logger.warning(f"[Job {job_id}] Failed to ingest {file_rel_path}: {e}")
results.append({"status": "error", "file": str(file_rel_path), "error": str(e)})
# Update progress every 5 files or at end
if (i + 1) % 5 == 0 or (i + 1) == total_files:
progress = 10 + int(((i + 1) / total_files) * 90)
update_job("running", progress, f"Indexed {i + 1}/{total_files} files...")
successes = [r for r in results if r.get("status") == "success"]
elapsed = time.time() - start_time
logger.info(f"[Job {job_id}] Selective semantic indexing complete in {elapsed:.1f}s")
update_job("completed", 100, f"Complete: {len(successes)}/{total_files} files indexed in {elapsed:.1f}s")
else:
# Full indexing (all files)
update_job("running", 10, "Starting full directory indexing...")
results = ingest_directory(project_path, kb_name)
successes = [r for r in results if r.get("status") == "success"]
elapsed = time.time() - start_time
logger.info(f"[Job {job_id}] Full semantic indexing complete in {elapsed:.1f}s")
update_job("completed", 100, f"Complete: {len(successes)} files indexed in {elapsed:.1f}s")
except Exception as e:
logger.error(f"[Job {job_id}] Semantic indexing failed: {e}")
update_job("failed", 0, "", str(e))
def _run_semantic_indexing_sync(kb_name: str, project_path: str, selective: bool, personalization: dict = None) -> dict:
"""
Synchronous semantic indexing for backward compatibility.
WARNING: This blocks the server! Use background=true for production.
Returns the final result dict.
"""
from app.core.tree_sitter_indexer import TreeSitterIndexer
from app.core.ingestion import ingest_directory, ingest_file
start_time = time.time()
if selective:
cache_path = str(Path(project_path) / ".claude-os" / "tree_sitter_cache.db")
indexer = TreeSitterIndexer(cache_path)
repo_map = indexer.index_directory(project_path, personalization)
indexer.close()
top_20_percent = max(1, int(len(repo_map.tags) * 0.2))
important_tags = repo_map.tags[:top_20_percent]
important_files = list(set(tag.file for tag in important_tags))
docs_patterns = ["*.md", "*.txt", "*.rst"]
doc_files = []
for pattern in docs_patterns:
doc_files.extend(Path(project_path).rglob(pattern))
all_files = list(set(important_files + [str(f.relative_to(project_path)) for f in doc_files]))
results = []
for file_rel_path in all_files:
file_path = Path(project_path) / file_rel_path
if file_path.exists() and file_path.is_file():
try:
result = ingest_file(str(file_path), kb_name, str(file_rel_path))
results.append({"status": "success", "file": str(file_rel_path)})
except Exception as e:
results.append({"status": "error", "file": str(file_rel_path), "error": str(e)})
successes = [r for r in results if r.get("status") == "success"]
elapsed = time.time() - start_time
return {
"success": True,
"kb_name": kb_name,
"mode": "selective",
"files_selected": len(all_files),
"files_indexed": len(successes),
"time_taken_seconds": elapsed,
"message": f"Selective semantic indexing complete: {len(successes)}/{len(all_files)} files indexed"
}
else:
results = ingest_directory(project_path, kb_name)
successes = [r for r in results if r.get("status") == "success"]
elapsed = time.time() - start_time
return {
"success": True,
"kb_name": kb_name,
"mode": "full",
"total_files": len(results),
"successful": len(successes),
"time_taken_seconds": elapsed,
"message": f"Full semantic indexing complete: {len(successes)} files indexed"
}
@app.post("/api/kb/{kb_name}/index-semantic")
async def api_index_semantic(kb_name: str, request: SemanticIndexRequest, background_tasks: BackgroundTasks):
"""
REST API: Semantic indexing with selective embedding.
Phase 2 of hybrid indexing.
By default (background=true), runs in background and returns immediately with job_id.
Check progress at GET /api/jobs/{job_id}
Set background=false for synchronous execution (WARNING: blocks server, use for small projects only).
"""
import uuid
# Validate KB exists
db_manager = get_sqlite_manager()
if not db_manager.collection_exists(kb_name):
raise HTTPException(status_code=404, detail=f"Knowledge base '{kb_name}' not found")
# Validate project path
if not Path(request.project_path).exists():
raise HTTPException(status_code=404, detail=f"Project path not found: {request.project_path}")
# Cleanup old jobs periodically
_cleanup_old_jobs()
# Synchronous mode (backward compatible, but blocks server)
if not request.background:
logger.warning(f"Running semantic indexing synchronously for {kb_name} - this will block the server!")
try:
result = _run_semantic_indexing_sync(
kb_name,
request.project_path,
request.selective,
request.personalization
)
return result
except Exception as e:
logger.error(f"Semantic indexing failed: {e}")
raise HTTPException(status_code=500, detail=str(e))
# Background mode (default, non-blocking)
job_id = f"semantic-{kb_name}-{uuid.uuid4().hex[:8]}"
with INDEXING_JOBS_LOCK:
INDEXING_JOBS[job_id] = {
"job_id": job_id,
"type": "semantic_indexing",
"kb_name": kb_name,
"project_path": request.project_path,
"selective": request.selective,
"status": "queued",
"progress": 0,
"message": "Job queued",
"started_at": time.time(),
"completed_at": None,
"error": None
}
# Queue the background task
background_tasks.add_task(
_run_semantic_indexing_background,
job_id,
kb_name,
request.project_path,
request.selective,
request.personalization
)
logger.info(f"Queued semantic indexing job {job_id} for {kb_name}")
return {
"success": True,
"job_id": job_id,
"kb_name": kb_name,
"mode": "selective" if request.selective else "full",
"status": "queued",
"message": f"Semantic indexing started in background. Check progress at GET /api/jobs/{job_id}"
}
@app.get("/api/jobs/{job_id}")
async def api_get_job_status(job_id: str):
"""Get the status of a background indexing job."""
with INDEXING_JOBS_LOCK:
if job_id not in INDEXING_JOBS:
raise HTTPException(status_code=404, detail=f"Job '{job_id}' not found")
return INDEXING_JOBS[job_id].copy()
@app.get("/api/jobs")
async def api_list_jobs():
"""List all indexing jobs (recent first)."""
with INDEXING_JOBS_LOCK:
jobs = list(INDEXING_JOBS.values())
# Sort by started_at descending
jobs.sort(key=lambda x: x.get("started_at", 0), reverse=True)
return {"jobs": jobs[:50]} # Return last 50 jobs
@app.get("/api/kb/{kb_name}/repo-map")
async def api_get_repo_map(
kb_name: str,
token_budget: int = 1024,
project_path: Optional[str] = None,
personalization: Optional[str] = None # JSON string
):
"""
REST API: Get compact repo map for Claude's prompt context.
Returns the most important symbols fitting within token budget.
"""
from app.core.tree_sitter_indexer import TreeSitterIndexer
import json
# Validate KB exists
db_manager = get_sqlite_manager()
if not db_manager.collection_exists(kb_name):
raise HTTPException(status_code=404, detail=f"Knowledge base '{kb_name}' not found")
try:
# Try to load cached repo map from KB first
# Query for repo_map.json document
results = db_manager.query_documents(kb_name, query_embedding=None, n_results=1)
if results and "documents" in results and len(results["documents"]) > 0:
# Check if first result is repo_map
metadata = results["metadatas"][0] if "metadatas" in results else []
if metadata and metadata[0].get("filename") == "repo_map.json":
# Load from KB
from app.core.tree_sitter_indexer import RepoMap
repo_map_data = json.loads(results["documents"][0][0])
repo_map = RepoMap.from_dict(repo_map_data)
# Apply personalization if provided
if personalization:
personalization_dict = json.loads(personalization)
indexer = TreeSitterIndexer()
ranked_tags = indexer.rank_symbols(repo_map.tags, repo_map.dependency_graph, personalization_dict)
repo_map.tags = ranked_tags
indexer.close()
# Generate compact map
indexer = TreeSitterIndexer()
compact_map = indexer.generate_repo_map(repo_map.tags, token_budget)
indexer.close()
return {
"success": True,
"kb_name": kb_name,
"repo_map": compact_map,
"token_count": len(compact_map) // 4, # Rough estimate
"total_symbols": repo_map.total_symbols,
"total_files": repo_map.total_files,
"source": "cached"
}
# If no cached repo map, generate on-the-fly (requires project_path)
if not project_path:
raise HTTPException(
status_code=400,
detail="No cached repo map found. Please provide project_path or run /index-structural first"
)
if not Path(project_path).exists():
raise HTTPException(status_code=404, detail=f"Project path not found: {project_path}")
# Generate repo map
cache_path = str(Path(project_path) / ".claude-os" / "tree_sitter_cache.db")
indexer = TreeSitterIndexer(cache_path)
personalization_dict = json.loads(personalization) if personalization else None
repo_map = indexer.index_directory(project_path, personalization_dict, token_budget)
compact_map = indexer.generate_repo_map(repo_map.tags, token_budget)
indexer.close()
return {
"success": True,
"kb_name": kb_name,
"repo_map": compact_map,
"token_count": len(compact_map) // 4,
"total_symbols": repo_map.total_symbols,
"total_files": repo_map.total_files,
"source": "generated"
}
except HTTPException:
raise
except Exception as e:
logger.error(f"Failed to get repo map: {e}")
raise HTTPException(status_code=500, detail=str(e))
# ============================================================================
# PROJECT MANAGEMENT ENDPOINTS (NEW - for Claude OS project integration)
# ============================================================================
class ProjectRequest(BaseModel):
"""Request model for creating a project."""
name: str
path: str
description: Optional[str] = ""
class ProjectKBFolderRequest(BaseModel):
"""Request model for setting KB folder."""
mcp_type: str # knowledge_docs, project_profile, project_index, project_memories
folder_path: str
auto_sync: bool = False
class ProjectDocumentIngestRequest(BaseModel):
"""Request model for ingesting a document into project MCP."""
mcp_type: str # knowledge_docs, project_profile, project_index, project_memories
filename: str
content: str
@app.get("/api/projects")
async def api_list_projects():
"""REST API: List all projects."""
try:
db_manager = get_sqlite_manager()
projects = db_manager.list_projects()
return {"projects": projects}
except Exception as e:
logger.error(f"Failed to list projects: {e}")
raise HTTPException(status_code=500, detail=str(e))
@app.post("/api/projects")
async def api_create_project(request: ProjectRequest):
"""REST API: Create a new project with 4 required MCPs."""
try:
db_manager = get_sqlite_manager()
# Create project
project = db_manager.create_project(
name=request.name,
path=request.path,
description=request.description
)
logger.info(f"Created project: {request.name}")
# Create 4 required MCPs
mcp_types = ["knowledge_docs", "project_profile", "project_index", "project_memories"]
mcps_created = []
for i, mcp_type in enumerate(mcp_types):
kb_name = f"{request.name}-{mcp_type}"
# Create KB for this MCP type
kb = db_manager.create_collection(
name=kb_name,
kb_type=KBType.GENERIC,
description=f"{mcp_type.replace('_', ' ').title()} for {request.name}"
)
# Link KB to project
db_manager.assign_kb_to_project(
project["id"],
kb["id"],
mcp_type
)
mcps_created.append({
"mcp_type": mcp_type,
"kb_name": kb_name,
"kb_id": kb["id"]
})
logger.info(f"Created MCP {mcp_type} KB: {kb_name}")
return {
"project": project,
"mcps": mcps_created,
"message": f"Project '{request.name}' created with 4 required MCPs"
}
except ValueError as e:
logger.error(f"Failed to create project: {e}")
raise HTTPException(status_code=409, detail=str(e))
except Exception as e:
logger.error(f"Failed to create project: {e}")
raise HTTPException(status_code=500, detail=str(e))
@app.get("/api/projects/{project_id}")
async def api_get_project(project_id: int):
"""REST API: Get project details with MCP assignments."""
try:
db_manager = get_sqlite_manager()
project = db_manager.get_project(project_id)
if not project:
raise HTTPException(status_code=404, detail=f"Project {project_id} not found")
# Get MCP KBs for this project
project_kbs = db_manager.get_project_kbs(project_id)
project_folders = db_manager.get_kb_folders(project_id)
return {
"project": project,
"mcps": project_kbs,
"folders": project_folders
}
except HTTPException:
raise
except Exception as e:
logger.error(f"Failed to get project: {e}")
raise HTTPException(status_code=500, detail=str(e))
@app.get("/api/projects/{project_id}/mcps")
async def api_get_project_mcps(project_id: int):
"""REST API: Get detailed MCP info for a project (KB names and IDs)."""
try:
db_manager = get_sqlite_manager()
project = db_manager.get_project(project_id)
if not project:
raise HTTPException(status_code=404, detail=f"Project {project_id} not found")
# Get detailed MCP info with KB names (returns dict)
mcps_dict = db_manager.get_project_mcps_detailed(project_id)
# Convert to list format for frontend
mcps_list = []
for mcp_type, mcp_data in mcps_dict.items():
# Get KB slug
kb = db_manager.get_collection_by_id(mcp_data['kb_id'])
mcps_list.append({
"mcp_type": mcp_type,
"kb_id": mcp_data['kb_id'],
"kb_name": mcp_data['kb_name'],
"kb_slug": kb.get('slug', '') if kb else ''
})
return {
"project_id": project_id,
"project_name": project['name'],
"project_path": project['path'],
"mcps": mcps_list
}
except HTTPException:
raise
except Exception as e:
logger.error(f"Failed to get project MCPs: {e}")
raise HTTPException(status_code=500, detail=str(e))
@app.post("/api/projects/{project_id}/folders")
async def api_set_kb_folder(project_id: int, request: ProjectKBFolderRequest):
"""REST API: Set the folder path for a project's MCP KB."""
try:
db_manager = get_sqlite_manager()
# Verify project exists
project = db_manager.get_project(project_id)
if not project:
raise HTTPException(status_code=404, detail=f"Project {project_id} not found")
# Verify MCP type is valid
valid_mcp_types = ["knowledge_docs", "project_profile", "project_index", "project_memories", "code_structure"]
if request.mcp_type not in valid_mcp_types:
raise HTTPException(
status_code=400,
detail=f"Invalid MCP type. Must be one of: {', '.join(valid_mcp_types)}"
)
# Verify folder exists
from pathlib import Path
folder_path = Path(request.folder_path)
if not folder_path.exists():
raise HTTPException(
status_code=400,
detail=f"Folder does not exist: {request.folder_path}"
)
# Get the KB name for this MCP type
mcps = db_manager.get_project_mcps_detailed(project_id)
if request.mcp_type not in mcps:
raise HTTPException(
status_code=404,
detail=f"MCP type {request.mcp_type} not found for project {project_id}"
)
kb_name = mcps[request.mcp_type]['kb_name']
# Set folder for this MCP type
result = db_manager.set_kb_folder(
project_id,
request.mcp_type,
request.folder_path,
request.auto_sync
)
logger.info(f"Set {request.mcp_type} folder for project {project_id}: {request.folder_path} (auto_sync={request.auto_sync})")
# Automatically sync the folder contents
from app.core.ingestion import ingest_directory
sync_results = None
try:
logger.info(f"Auto-syncing folder {request.folder_path} to {kb_name}...")
results = ingest_directory(request.folder_path, kb_name)
successes = [r for r in results if r.get("status") == "success"]
failures = [r for r in results if r.get("status") == "error"]
sync_results = {
"total_files": len(results),
"successful": len(successes),
"failed": len(failures)
}
logger.info(f"Folder sync complete: {len(successes)}/{len(results)} files uploaded successfully")
except Exception as e:
logger.error(f"Failed to sync folder: {e}")
# Don't fail the whole request if sync fails
sync_results = {
"error": str(e)
}
return {
"project_id": project_id,
"mcp_type": request.mcp_type,
"folder_path": request.folder_path,
"auto_sync": request.auto_sync,
"sync_results": sync_results,
"message": f"Folder configured for {request.mcp_type}"
}
except HTTPException:
raise
except Exception as e:
logger.error(f"Failed to set KB folder: {e}")
raise HTTPException(status_code=500, detail=str(e))
@app.get("/api/projects/{project_id}/folders")
async def api_get_kb_folders(project_id: int):
"""REST API: Get folder configurations for a project's MCPs."""
try:
db_manager = get_sqlite_manager()
# Verify project exists
project = db_manager.get_project(project_id)
if not project:
raise HTTPException(status_code=404, detail=f"Project {project_id} not found")
# Get folder configurations
folders = db_manager.get_kb_folders(project_id)
return {
"project_id": project_id,
"folders": folders
}
except HTTPException:
raise
except Exception as e:
logger.error(f"Failed to get KB folders: {e}")
raise HTTPException(status_code=500, detail=str(e))
@app.post("/api/projects/{project_id}/ingest-document")
async def api_ingest_document(project_id: int, request: ProjectDocumentIngestRequest):
"""REST API: Ingest a document directly into a project's MCP KB."""
try:
db_manager = get_sqlite_manager()
# Verify project exists
project = db_manager.get_project(project_id)
if not project:
raise HTTPException(status_code=404, detail=f"Project {project_id} not found")
# Verify MCP type is valid
valid_mcp_types = ["knowledge_docs", "project_profile", "project_index", "project_memories", "code_structure"]
if request.mcp_type not in valid_mcp_types:
raise HTTPException(
status_code=400,
detail=f"Invalid MCP type. Must be one of: {', '.join(valid_mcp_types)}"
)
# Get the KB name for this MCP type
mcps = db_manager.get_project_mcps_detailed(project_id)
if request.mcp_type not in mcps:
raise HTTPException(
status_code=404,
detail=f"MCP type {request.mcp_type} not found for project {project_id}"
)
kb_name = mcps[request.mcp_type]['kb_name']
# Ingest the document into the KB
from app.core.ingestion import ingest_documents
try:
logger.info(f"Ingesting document {request.filename} to {kb_name} for project {project_id}...")
result = ingest_documents(
collection_name=kb_name,
documents=[request.content],
metadatas=[{
"filename": request.filename,
"type": "text/markdown",
"project_id": project_id
}]
)
logger.info(f"Document {request.filename} ingested successfully")
return {
"project_id": project_id,
"mcp_type": request.mcp_type,
"filename": request.filename,
"kb_name": kb_name,
"status": "success",
"message": f"Document {request.filename} ingested into {request.mcp_type}"
}
except Exception as e:
logger.error(f"Failed to ingest document {request.filename}: {e}")
raise HTTPException(status_code=500, detail=f"Failed to ingest document: {str(e)}")
except HTTPException:
raise
except Exception as e:
logger.error(f"Failed to ingest document: {e}")
raise HTTPException(status_code=500, detail=str(e))
@app.delete("/api/projects/{project_id}")
async def api_delete_project(project_id: int):
"""REST API: Delete a project and its associated KBs."""
try:
db_manager = get_sqlite_manager()
# Get project to verify it exists
project = db_manager.get_project(project_id)
if not project:
raise HTTPException(status_code=404, detail=f"Project {project_id} not found")
# Get all KBs for this project
project_kbs = db_manager.get_project_kbs(project_id)
# Delete all KBs associated with this project
for mcp_type, kb_id in project_kbs.items():
# Get KB name to delete
collections = db_manager.list_collections()
for kb in collections:
if kb.get("id") == kb_id:
db_manager.delete_collection(kb["name"])
logger.info(f"Deleted KB {kb['name']} for project {project_id}")
break
# Delete project (cascades to project_mcps and project_kb_folders)
# Note: SQLite doesn't have CASCADE by default, so we manually delete
conn = db_manager.get_connection()
try:
cursor = conn.cursor()
cursor.execute("DELETE FROM project_kb_folders WHERE project_id = ?", (project_id,))
cursor.execute("DELETE FROM project_mcps WHERE project_id = ?", (project_id,))
cursor.execute("DELETE FROM projects WHERE id = ?", (project_id,))
conn.commit()
finally:
conn.close()
logger.info(f"Deleted project {project_id}")
return {
"message": f"Project {project_id} and all associated KBs deleted",
"project_id": project_id
}
except HTTPException:
raise
except Exception as e:
logger.error(f"Failed to delete project: {e}")
raise HTTPException(status_code=500, detail=str(e))
# ============================================================================
# PROJECT HOOKS ENDPOINTS (for KB folder synchronization)
# ============================================================================
class HookRequest(BaseModel):
"""Request model for configuring hooks."""
folder_path: str
file_patterns: Optional[List[str]] = None
class SyncRequest(BaseModel):
"""Request model for syncing KB folders."""
mcp_type: Optional[str] = None # If None, sync all
@app.post("/api/projects/{project_id}/hooks/{mcp_type}/enable")
async def api_enable_hook(project_id: int, mcp_type: str, request: HookRequest):
"""Enable automatic KB synchronization for a folder."""
try:
hook = get_project_hook(project_id)
# Enable hook
hook_config = hook.enable_kb_autosync(
mcp_type,
request.folder_path,
request.file_patterns
)
return {
"project_id": project_id,
"mcp_type": mcp_type,
"hook": hook_config,
"message": f"Hook enabled for {mcp_type}"
}
except Exception as e:
logger.error(f"Failed to enable hook: {e}")
raise HTTPException(status_code=500, detail=str(e))
@app.post("/api/projects/{project_id}/hooks/{mcp_type}/disable")
async def api_disable_hook(project_id: int, mcp_type: str):
"""Disable automatic KB synchronization."""
try:
hook = get_project_hook(project_id)
hook.disable_kb_autosync(mcp_type)
return {
"project_id": project_id,
"mcp_type": mcp_type,
"message": f"Hook disabled for {mcp_type}"
}
except Exception as e:
logger.error(f"Failed to disable hook: {e}")
raise HTTPException(status_code=500, detail=str(e))
@app.post("/api/projects/{project_id}/hooks/sync")
async def api_sync_hooks(project_id: int, request: Optional[SyncRequest] = None):
"""Manually sync KB folders for a project."""
try:
hook = get_project_hook(project_id)
if request and request.mcp_type:
# Sync specific MCP type
result = hook.sync_kb_folder(request.mcp_type)
return {
"project_id": project_id,
"sync_result": result
}
else:
# Sync all folders
results = hook.sync_all_folders()
return {
"project_id": project_id,
"sync_results": results
}
except Exception as e:
logger.error(f"Failed to sync hooks: {e}")
raise HTTPException(status_code=500, detail=str(e))
@app.get("/api/projects/{project_id}/hooks")
async def api_get_hooks_status(project_id: int):
"""Get hook status for a project."""
try:
hook = get_project_hook(project_id)
status = hook.get_hook_status()
return {
"project_id": project_id,
"status": status
}
except Exception as e:
logger.error(f"Failed to get hooks status: {e}")
raise HTTPException(status_code=500, detail=str(e))
# ============================================================================
# FILE WATCHER ENDPOINTS (for automatic folder synchronization)
# ============================================================================
@app.post("/api/watcher/start/{project_id}")
async def api_start_watcher(project_id: int):
"""Start file watcher for a project."""
try:
watcher = get_global_watcher()
watcher.start_project(project_id)
return {
"project_id": project_id,
"message": "File watcher started",
"status": watcher.get_status()
}
except Exception as e:
logger.error(f"Failed to start watcher: {e}")
raise HTTPException(status_code=500, detail=str(e))
@app.post("/api/watcher/stop/{project_id}")
async def api_stop_watcher(project_id: int):
"""Stop file watcher for a project."""
try:
watcher = get_global_watcher()
watcher.stop_project(project_id)
return {
"project_id": project_id,
"message": "File watcher stopped",
"status": watcher.get_status()
}
except Exception as e:
logger.error(f"Failed to stop watcher: {e}")
raise HTTPException(status_code=500, detail=str(e))
@app.post("/api/watcher/restart/{project_id}")
async def api_restart_watcher(project_id: int):
"""Restart file watcher for a project."""
try:
watcher = get_global_watcher()
watcher.restart_project(project_id)
return {
"project_id": project_id,
"message": "File watcher restarted",
"status": watcher.get_status()
}
except Exception as e:
logger.error(f"Failed to restart watcher: {e}")
raise HTTPException(status_code=500, detail=str(e))
@app.get("/api/watcher/status")
async def api_watcher_status():
"""Get file watcher status."""
try:
watcher = get_global_watcher()
return {"status": watcher.get_status()}
except Exception as e:
logger.error(f"Failed to get watcher status: {e}")
raise HTTPException(status_code=500, detail=str(e))
# ============================================================================
# SPEC WATCHER ENDPOINTS (for real-time agent-os spec syncing)
# ============================================================================
@app.post("/api/spec-watcher/start/{project_id}")
async def api_start_spec_watcher(project_id: int):
"""Start spec watcher for a project."""
try:
from app.core.spec_watcher import get_global_spec_watcher
# Get project path
db_manager = get_sqlite_manager()
project = db_manager.get_project(project_id)
if not project:
raise HTTPException(status_code=404, detail="Project not found")
spec_watcher = get_global_spec_watcher()
spec_watcher.start_project(project_id, project['path'])
return {
"project_id": project_id,
"message": "Spec watcher started",
"status": spec_watcher.get_status()
}
except Exception as e:
logger.error(f"Failed to start spec watcher: {e}")
raise HTTPException(status_code=500, detail=str(e))
@app.post("/api/spec-watcher/stop/{project_id}")
async def api_stop_spec_watcher(project_id: int):
"""Stop spec watcher for a project."""
try:
from app.core.spec_watcher import get_global_spec_watcher
spec_watcher = get_global_spec_watcher()
spec_watcher.stop_project(project_id)
return {
"project_id": project_id,
"message": "Spec watcher stopped",
"status": spec_watcher.get_status()
}
except Exception as e:
logger.error(f"Failed to stop spec watcher: {e}")
raise HTTPException(status_code=500, detail=str(e))
@app.post("/api/spec-watcher/start-all")
async def api_start_all_spec_watchers():
"""Start spec watchers for all projects."""
try:
from app.core.spec_watcher import get_global_spec_watcher
spec_watcher = get_global_spec_watcher()
spec_watcher.start_all()
return {
"message": "Spec watchers started for all projects",
"status": spec_watcher.get_status()
}
except Exception as e:
logger.error(f"Failed to start all spec watchers: {e}")
raise HTTPException(status_code=500, detail=str(e))
@app.get("/api/spec-watcher/status")
async def api_spec_watcher_status():
"""Get spec watcher status."""
try:
from app.core.spec_watcher import get_global_spec_watcher
spec_watcher = get_global_spec_watcher()
return {"status": spec_watcher.get_status()}
except Exception as e:
logger.error(f"Failed to get spec watcher status: {e}")
raise HTTPException(status_code=500, detail=str(e))
# ============================================================================
# SPEC TRACKING ENDPOINTS (for agent-os integration and Kanban board)
# ============================================================================
@app.get("/api/projects/{project_id}/specs")
async def api_get_project_specs(project_id: int):
"""Get all specs for a project."""
try:
manager = SpecManager()
specs = manager.get_project_specs(project_id)
return {"project_id": project_id, "specs": specs}
except Exception as e:
logger.error(f"Failed to get specs: {e}")
raise HTTPException(status_code=500, detail=str(e))
@app.get("/api/specs/{spec_id}/tasks")
async def api_get_spec_tasks(spec_id: int):
"""Get all tasks for a spec."""
try:
manager = SpecManager()
tasks = manager.get_spec_tasks(spec_id)
return {"spec_id": spec_id, "tasks": tasks}
except Exception as e:
logger.error(f"Failed to get tasks: {e}")
raise HTTPException(status_code=500, detail=str(e))
class TaskStatusUpdate(BaseModel):
status: str
actual_minutes: Optional[int] = None
@app.patch("/api/tasks/{task_id}/status")
async def api_update_task_status(task_id: int, update: TaskStatusUpdate):
"""Update a task's status."""
try:
manager = SpecManager()
result = manager.update_task_status(
task_id,
update.status,
update.actual_minutes
)
if not result['success']:
raise HTTPException(status_code=404, detail=result.get('error', 'Task not found'))
return result
except HTTPException:
raise
except Exception as e:
logger.error(f"Failed to update task status: {e}")
raise HTTPException(status_code=500, detail=str(e))
@app.post("/api/projects/{project_id}/specs/sync")
async def api_sync_project_specs(project_id: int):
"""Sync specs from project's agent-os folder."""
try:
# Get project path
manager_db = get_sqlite_manager()
project = manager_db.get_project(project_id)
if not project:
raise HTTPException(status_code=404, detail="Project not found")
# Sync specs
spec_manager = SpecManager()
result = spec_manager.sync_project_specs(project_id, project['path'])
return {
"project_id": project_id,
"message": "Specs synced successfully",
**result
}
except HTTPException:
raise
except Exception as e:
logger.error(f"Failed to sync specs: {e}")
raise HTTPException(status_code=500, detail=str(e))
@app.get("/api/projects/{project_id}/kanban")
async def api_get_kanban_view(project_id: int, include_archived: bool = False):
"""Get Kanban board view for a project."""
try:
manager = SpecManager()
# Get specs with archive filter
specs = manager.get_project_specs(project_id, include_archived)
# Build kanban manually with filtered specs
kanban = {
"project_id": project_id,
"specs": [],
"summary": {
"total_specs": len(specs),
"total_tasks": 0,
"completed_tasks": 0,
"archived_count": sum(1 for s in specs if s.get('archived', False))
}
}
for spec in specs:
tasks = manager.get_spec_tasks(spec['id'])
# Group tasks by status
task_groups = {
"todo": [t for t in tasks if t['status'] == 'todo'],
"in_progress": [t for t in tasks if t['status'] == 'in_progress'],
"done": [t for t in tasks if t['status'] == 'done'],
"blocked": [t for t in tasks if t['status'] == 'blocked']
}
kanban['specs'].append({
**spec,
"tasks": task_groups,
"task_count_by_status": {
"todo": len(task_groups['todo']),
"in_progress": len(task_groups['in_progress']),
"done": len(task_groups['done']),
"blocked": len(task_groups['blocked'])
}
})
kanban['summary']['total_tasks'] += spec['total_tasks']
kanban['summary']['completed_tasks'] += spec['completed_tasks']
return kanban
except Exception as e:
logger.error(f"Failed to get kanban view: {e}")
raise HTTPException(status_code=500, detail=str(e))
@app.post("/api/specs/{spec_id}/archive")
async def api_archive_spec(spec_id: int):
"""Archive a spec."""
try:
manager = SpecManager()
result = manager.archive_spec(spec_id)
return result
except Exception as e:
logger.error(f"Failed to archive spec: {e}")
raise HTTPException(status_code=500, detail=str(e))
@app.post("/api/specs/{spec_id}/unarchive")
async def api_unarchive_spec(spec_id: int):
"""Unarchive a spec."""
try:
manager = SpecManager()
result = manager.unarchive_spec(spec_id)
return result
except Exception as e:
logger.error(f"Failed to unarchive spec: {e}")
raise HTTPException(status_code=500, detail=str(e))
# ============================================================================
# OLLAMA ENDPOINTS
# ============================================================================
@app.get("/api/ollama/models")
async def api_list_ollama_models():
"""REST API: List available Ollama models."""
try:
response = requests.get(f"{Config.OLLAMA_HOST}/api/tags", timeout=2)
if response.status_code == 200:
models = response.json().get("models", [])
return {"models": models}
else:
raise HTTPException(status_code=503, detail="Ollama service unavailable")
except Exception as e:
logger.error(f"Failed to list Ollama models: {e}")
raise HTTPException(status_code=503, detail=str(e))
# ============================================================================
# SERVICE DASHBOARD ENDPOINTS (NEW - Real-time service monitoring)
# ============================================================================
import subprocess
import shutil
class ServiceControlRequest(BaseModel):
"""Request model for service control."""
action: str # start, stop, restart
def check_process_running(process_name: str) -> dict:
"""
Check if a process is running by name.
Returns:
dict with status, pid, memory, cpu
"""
try:
# Use pgrep to find process
result = subprocess.run(
["pgrep", "-f", process_name],
capture_output=True,
text=True,
timeout=2
)
if result.returncode == 0 and result.stdout.strip():
pids = result.stdout.strip().split('\n')
pid = pids[0] # Get first matching PID
# Get process stats using ps
ps_result = subprocess.run(
["ps", "-p", pid, "-o", "pid,%cpu,%mem,command"],
capture_output=True,
text=True,
timeout=2
)
if ps_result.returncode == 0:
lines = ps_result.stdout.strip().split('\n')
if len(lines) > 1:
parts = lines[1].split(None, 3)
return {
"running": True,
"pid": int(pid),
"cpu": float(parts[1]) if len(parts) > 1 else 0.0,
"memory": float(parts[2]) if len(parts) > 2 else 0.0,
"status": "running"
}
return {
"running": False,
"pid": None,
"cpu": 0.0,
"memory": 0.0,
"status": "stopped"
}
except Exception as e:
logger.warning(f"Failed to check process {process_name}: {e}")
return {
"running": False,
"pid": None,
"cpu": 0.0,
"memory": 0.0,
"status": "unknown",
"error": str(e)
}
def check_port_listening(port: int) -> bool:
"""Check if a port is being listened on."""
try:
# Use netstat or ss to check if port is listening
result = subprocess.run(
["sh", "-c", f"lsof -i :{port} -t || netstat -tuln | grep :{port} || ss -tuln | grep :{port}"],
capture_output=True,
text=True,
timeout=2
)
return result.returncode == 0 and result.stdout.strip() != ""
except Exception as e:
logger.warning(f"Failed to check port {port}: {e}")
return False
@app.get("/api/services/status")
async def api_get_services_status():
"""
Get status of all Claude OS services.
Returns real-time status for:
- MCP Server (this server)
- Frontend (Vite dev server)
- Redis
- RQ Worker
- Ollama
- File Watcher
"""
services = []
# 1. MCP Server (always running since we're responding)
mcp_status = {
"name": "MCP Server",
"type": "mcp_server",
"port": Config.MCP_SERVER_PORT,
"running": True,
"status": "running",
"pid": os.getpid(),
"cpu": 0.0,
"memory": 0.0,
"description": "Main API server and MCP endpoint"
}
services.append(mcp_status)
# 2. Frontend (Vite dev server on port 5173)
frontend_port = 5173
frontend_process = check_process_running("vite")
frontend_status = {
"name": "Frontend",
"type": "frontend",
"port": frontend_port,
"running": frontend_process["running"] or check_port_listening(frontend_port),
"status": frontend_process["status"],
"pid": frontend_process.get("pid"),
"cpu": frontend_process.get("cpu", 0.0),
"memory": frontend_process.get("memory", 0.0),
"description": "React web interface"
}
services.append(frontend_status)
# 3. Redis (port 6379)
redis_port = 6379
redis_process = check_process_running("redis-server")
redis_status = {
"name": "Redis",
"type": "redis",
"port": redis_port,
"running": redis_process["running"] or check_port_listening(redis_port),
"status": redis_process["status"],
"pid": redis_process.get("pid"),
"cpu": redis_process.get("cpu", 0.0),
"memory": redis_process.get("memory", 0.0),
"description": "Job queue and caching"
}
services.append(redis_status)
# 4. RQ Worker
rq_process = check_process_running("rq worker")
rq_status = {
"name": "RQ Worker",
"type": "rq_worker",
"port": None,
"running": rq_process["running"],
"status": rq_process["status"],
"pid": rq_process.get("pid"),
"cpu": rq_process.get("cpu", 0.0),
"memory": rq_process.get("memory", 0.0),
"description": "Background job processor"
}
services.append(rq_status)
# 5. Ollama (port 11434)
ollama_port = 11434
ollama_running = False
try:
response = requests.get(f"{Config.OLLAMA_HOST}/api/tags", timeout=1)
ollama_running = response.status_code == 200
except:
ollama_running = check_port_listening(ollama_port)
ollama_process = check_process_running("ollama")
ollama_status = {
"name": "Ollama",
"type": "ollama",
"port": ollama_port,
"running": ollama_running or ollama_process["running"],
"status": "running" if ollama_running else ollama_process["status"],
"pid": ollama_process.get("pid"),
"cpu": ollama_process.get("cpu", 0.0),
"memory": ollama_process.get("memory", 0.0),
"description": "Local AI model server"
}
services.append(ollama_status)
# 6. File Watcher
try:
watcher = get_global_watcher()
watcher_status_data = watcher.get_status()
# Watcher is running if it has projects being watched
watcher_running = watcher_status_data.get("projects_watched", 0) > 0
except:
watcher_running = False
watcher_status = {
"name": "File Watcher",
"type": "file_watcher",
"port": None,
"running": watcher_running,
"status": "running" if watcher_running else "stopped",
"pid": None,
"cpu": 0.0,
"memory": 0.0,
"description": "Automatic folder sync"
}
services.append(watcher_status)
# Calculate summary
total = len(services)
running = sum(1 for s in services if s["running"])
stopped = total - running
return {
"services": services,
"summary": {
"total": total,
"running": running,
"stopped": stopped,
"health": "healthy" if running >= total - 1 else ("degraded" if running > 0 else "critical")
},
"timestamp": time.time()
}
@app.post("/api/services/{service_type}/control")
async def api_control_service(service_type: str, request: ServiceControlRequest):
"""
Control a service (start/stop/restart).
Note: This is a basic implementation. In production, you'd want more
sophisticated service management (systemd, supervisord, etc.)
"""
action = request.action.lower()
if action not in ["start", "stop", "restart"]:
raise HTTPException(status_code=400, detail=f"Invalid action: {action}")
# For now, return a helpful message about manual control
# In a production system, you'd integrate with systemd or supervisord
if service_type == "mcp_server":
return {
"success": False,
"message": "Cannot control MCP server from itself. Use ./start.sh or stop_all_services.sh",
"service": service_type
}
service_commands = {
"frontend": {
"start": "cd frontend && npm run dev &",
"stop": "pkill -f 'vite'",
"script": "frontend/package.json"
},
"redis": {
"start": "redis-server --daemonize yes",
"stop": "redis-cli shutdown",
"script": None
},
"rq_worker": {
"start": "rq worker &",
"stop": "pkill -f 'rq worker'",
"script": None
},
"ollama": {
"start": "ollama serve &",
"stop": "pkill -f ollama",
"script": None
}
}
if service_type not in service_commands:
raise HTTPException(status_code=404, detail=f"Unknown service: {service_type}")
commands = service_commands[service_type]
return {
"success": False,
"message": f"Service control not fully implemented yet. Manual command:",
"manual_command": commands.get(action),
"service": service_type,
"action": action,
"note": "Use start_all_services.sh or stop_all_services.sh for full control"
}
@app.get("/api/browse-directory")
async def api_browse_directory(path: str = None):
"""REST API: Browse directories and return subdirectories."""
try:
from pathlib import Path
import os
# If no path provided or empty string, start from home directory
if not path or path.strip() == '':
path = str(Path.home())
# Normalize and validate path
dir_path = Path(path).expanduser().resolve()
# Security check: ensure path exists and is a directory
if not dir_path.exists():
raise HTTPException(status_code=404, detail=f"Directory not found: {path}")
if not dir_path.is_dir():
raise HTTPException(status_code=400, detail=f"Path is not a directory: {path}")
# Get subdirectories with robust error handling
subdirs = []
try:
# Collect items first to handle iteration errors
items = []
try:
items = list(dir_path.iterdir())
except PermissionError:
raise HTTPException(status_code=403, detail=f"Permission denied: {path}")
# Sort items with error handling for broken symlinks
def safe_sort_key(item):
try:
return str(item).lower()
except Exception as e:
logger.warning(f"Error sorting item {item}: {e}")
return ""
sorted_items = sorted(items, key=safe_sort_key)
# Process each item with individual error handling
for item in sorted_items:
try:
# Skip hidden files/directories
if item.name.startswith('.'):
continue
# Check if it's a directory (this can fail for broken symlinks)
if item.is_dir():
subdirs.append({
"name": item.name,
"path": str(item),
"is_dir": True
})
except (OSError, PermissionError) as e:
# Skip items that cause errors (broken symlinks, permission issues, etc.)
logger.warning(f"Skipping item {item.name} in {dir_path}: {e}")
continue
except Exception as e:
# Catch any other unexpected errors and skip the item
logger.warning(f"Unexpected error processing item {item.name} in {dir_path}: {e}")
continue
except HTTPException:
raise
except Exception as e:
logger.error(f"Error iterating directory {dir_path}: {e}")
raise HTTPException(status_code=500, detail=f"Error reading directory: {str(e)}")
return {
"current_path": str(dir_path),
"parent_path": str(dir_path.parent) if dir_path.parent != dir_path else None,
"subdirectories": subdirs
}
except HTTPException:
raise
except Exception as e:
logger.error(f"Failed to browse directory: {e}")
raise HTTPException(status_code=500, detail=str(e))
# Health check endpoint (detailed version at end of file)
# MCP Protocol Endpoints
@app.post("/")
async def mcp_root(request: Request):
"""Main MCP endpoint - handles JSON-RPC requests."""
return await handle_mcp_request(request)
@app.post("/mcp")
async def mcp_endpoint(request: Request):
"""Global MCP endpoint - exposes all KBs."""
return await handle_mcp_request(request, kb_filter=None)
@app.post("/mcp/kb/{kb_slug}")
async def mcp_kb_endpoint(kb_slug: str, request: Request):
"""KB-specific MCP endpoint - only exposes tools for this KB."""
# Get KB name from slug
db_manager = get_sqlite_manager()
kb_name = db_manager.get_kb_by_slug(kb_slug)
if not kb_name:
return JSONResponse({
"jsonrpc": "2.0",
"id": None,
"error": {
"code": -32000,
"message": f"Knowledge base with slug '{kb_slug}' not found"
}
}, status_code=404)
return await handle_mcp_request(request, kb_filter=kb_name)
async def handle_mcp_request(request: Request, kb_filter: Optional[str] = None) -> JSONResponse:
"""
Handle MCP JSON-RPC requests.
Args:
request: FastAPI request object
kb_filter: If provided, only expose tools for this specific KB
"""
try:
body = await request.json()
method = body.get("method")
params = body.get("params", {})
request_id = body.get("id")
logger.info(f"MCP request: {method} (kb_filter={kb_filter})")
# Handle MCP protocol methods
if method == "initialize":
server_name = f"claude-os-{kb_filter}" if kb_filter else "claude-os"
return JSONResponse({
"jsonrpc": "2.0",
"id": request_id,
"result": {
"protocolVersion": "2024-11-05",
"capabilities": {
"tools": {}
},
"serverInfo": {
"name": server_name,
"version": "1.0.0"
}
}
})
elif method == "tools/list":
# Filter tools based on kb_filter
if kb_filter:
# KB-specific endpoint: only expose search tool for this KB
tools_list = [
{
"name": "search",
"description": f"Search the '{kb_filter}' knowledge base using RAG with optional advanced features",
"inputSchema": {
"type": "object",
"properties": {
"query": {"type": "string", "description": "The search query"},
"use_hybrid": {"type": "boolean", "description": "Enable hybrid search (vector + BM25)", "default": False},
"use_rerank": {"type": "boolean", "description": "Enable reranking for better relevance", "default": False},
"use_agentic": {"type": "boolean", "description": "Enable agentic RAG for complex queries", "default": False}
},
"required": ["query"]
}
},
{
"name": "get_stats",
"description": f"Get statistics for the '{kb_filter}' knowledge base",
"inputSchema": {
"type": "object",
"properties": {}
}
},
{
"name": "list_documents",
"description": f"List all documents in the '{kb_filter}' knowledge base",
"inputSchema": {
"type": "object",
"properties": {}
}
}
]
else:
# Global endpoint: expose all tools
tools_list = [
{"name": name, **info}
for name, info in TOOLS.items()
]
return JSONResponse({
"jsonrpc": "2.0",
"id": request_id,
"result": {"tools": tools_list}
})
elif method == "tools/call":
tool_name = params.get("name")
arguments = params.get("arguments", {})
# Handle KB-specific endpoint tool calls
if kb_filter:
# Inject kb_name into arguments for KB-specific tools
if tool_name == "search":
result = await search_knowledge_base(kb_name=kb_filter, **arguments)
elif tool_name == "get_stats":
result = await get_kb_stats(kb_name=kb_filter)
elif tool_name == "list_documents":
result = await list_documents(kb_name=kb_filter)
else:
return JSONResponse({
"jsonrpc": "2.0",
"id": request_id,
"error": {
"code": -32601,
"message": f"Unknown tool: {tool_name}"
}
})
else:
# Global endpoint: route to appropriate tool function
if tool_name == "search_knowledge_base":
result = await search_knowledge_base(**arguments)
elif tool_name == "list_knowledge_bases":
result = await list_knowledge_bases()
elif tool_name == "list_knowledge_bases_by_type":
result = await list_knowledge_bases_by_type(**arguments)
elif tool_name == "create_knowledge_base":
result = await create_knowledge_base(**arguments)
elif tool_name == "get_kb_stats":
result = await get_kb_stats(**arguments)
elif tool_name == "list_documents":
result = await list_documents(**arguments)
elif tool_name == "ingest_agent_os_profile":
result = await ingest_agent_os_profile(**arguments)
elif tool_name == "get_agent_os_stats":
result = await get_agent_os_stats(**arguments)
elif tool_name == "get_standards":
result = await get_standards(**arguments)
elif tool_name == "get_workflows":
result = await get_workflows(**arguments)
elif tool_name == "get_specs":
result = await get_specs(**arguments)
elif tool_name == "get_product_context":
result = await get_product_context(**arguments)
else:
return JSONResponse({
"jsonrpc": "2.0",
"id": request_id,
"error": {
"code": -32601,
"message": f"Unknown tool: {tool_name}"
}
})
return JSONResponse({
"jsonrpc": "2.0",
"id": request_id,
"result": {
"content": [
{
"type": "text",
"text": str(result)
}
]
}
})
else:
return JSONResponse({
"jsonrpc": "2.0",
"id": request_id,
"error": {
"code": -32601,
"message": f"Method not found: {method}"
}
})
except Exception as e:
logger.error(f"MCP request failed: {e}", exc_info=True)
return JSONResponse({
"jsonrpc": "2.0",
"id": body.get("id") if 'body' in locals() else None,
"error": {
"code": -32603,
"message": str(e)
}
})
# ============================================================================
# Authentication Endpoints
# ============================================================================
from mcp_server.auth import (
authenticate_user,
create_access_token,
is_auth_enabled,
get_current_user
)
from datetime import timedelta
class LoginRequest(BaseModel):
email: str
password: str
@app.post("/api/auth/login")
async def login(request: LoginRequest):
"""Login endpoint - returns JWT token if credentials are valid."""
if not is_auth_enabled():
raise HTTPException(
status_code=501,
detail="Authentication is not configured. Set CLAUDE_OS_EMAIL and CLAUDE_OS_PASSWORD in environment."
)
if not authenticate_user(request.email, request.password):
raise HTTPException(
status_code=401,
detail="Incorrect email or password"
)
access_token = create_access_token(
data={"sub": request.email},
expires_delta=timedelta(days=7)
)
return {
"access_token": access_token,
"token_type": "bearer",
"email": request.email
}
@app.get("/api/auth/me")
async def get_me(current_user: dict = Depends(get_current_user)):
"""Get current user info."""
return current_user
@app.get("/api/auth/status")
async def auth_status():
"""Check if authentication is enabled."""
return {
"auth_enabled": is_auth_enabled()
}
# ============================================================================
# Health Check
# ============================================================================
@app.get("/health")
async def health_check():
"""
Health check endpoint that verifies all system components.
Returns detailed status for monitoring.
"""
health_status = {
"status": "healthy",
"components": {},
"timestamp": None
}
from datetime import datetime
health_status["timestamp"] = datetime.utcnow().isoformat()
# Check SQLite Database
try:
db_manager = get_sqlite_manager()
collections = db_manager.list_collections()
# Get SQLite table count
conn = db_manager.get_connection()
cursor = conn.cursor()
cursor.execute("SELECT COUNT(*) FROM sqlite_master WHERE type='table';")
table_count = cursor.fetchone()[0]
health_status["components"]["sqlite"] = {
"status": "healthy",
"connected": True,
"database": "claude-os.db",
"tables": table_count,
"knowledge_bases": len(collections)
}
except Exception as e:
health_status["status"] = "unhealthy"
health_status["components"]["sqlite"] = {
"status": "unhealthy",
"connected": False,
"error": str(e)
}
# Check Ollama
try:
response = requests.get(f"{Config.OLLAMA_HOST}/api/tags", timeout=2)
if response.status_code == 200:
models = response.json().get("models", [])
model_names = [m["name"] for m in models]
# Check for required models
required_models = ["nomic-embed-text:latest", "llama3.2:3b"]
missing_models = [m for m in required_models if m not in model_names]
health_status["components"]["ollama"] = {
"status": "healthy" if not missing_models else "degraded",
"running": True,
"models_installed": len(models),
"required_models": required_models,
"missing_models": missing_models
}
if missing_models:
health_status["status"] = "degraded"
else:
health_status["status"] = "degraded"
health_status["components"]["ollama"] = {
"status": "degraded",
"running": True,
"error": f"Unexpected status code: {response.status_code}"
}
except Exception as e:
health_status["status"] = "unhealthy"
health_status["components"]["ollama"] = {
"status": "unhealthy",
"running": False,
"error": str(e)
}
# Return appropriate HTTP status code
status_code = 200 if health_status["status"] in ["healthy", "degraded"] else 503
return JSONResponse(content=health_status, status_code=status_code)
# ============================================================================
# STARTUP/SHUTDOWN EVENTS
# ============================================================================
@app.on_event("startup")
async def startup_event():
"""Run tasks on server startup."""
logger.info("🚀 Starting up Claude OS MCP Server...")
# Auto-start spec watchers for all projects
try:
from app.core.spec_watcher import get_global_spec_watcher
spec_watcher = get_global_spec_watcher()
spec_watcher.start_all()
status = spec_watcher.get_status()
if status['enabled']:
logger.info(f"✅ Spec watchers started for {status['projects_watched']} project(s)")
else:
logger.info("ℹ️ No projects found - spec watchers will start when projects are created")
except Exception as e:
logger.error(f"❌ Failed to start spec watchers: {e}")
@app.on_event("shutdown")
async def shutdown_event():
"""Run tasks on server shutdown."""
logger.info("👋 Shutting down Claude OS MCP Server...")
# Stop all spec watchers
try:
from app.core.spec_watcher import get_global_spec_watcher
spec_watcher = get_global_spec_watcher()
spec_watcher.stop_all()
logger.info("✅ Spec watchers stopped")
except Exception as e:
logger.error(f"❌ Failed to stop spec watchers: {e}")
def main():
"""Start the MCP server."""
# Validate configuration before starting
try:
Config.validate_config()
logger.info("✅ Configuration validated successfully")
except ValueError as e:
logger.error(f"❌ Configuration validation failed:\n{e}")
sys.exit(1)
logger.info(f"Starting Claude OS MCP Server on {Config.MCP_SERVER_HOST}:{Config.MCP_SERVER_PORT}")
logger.info(f"MCP endpoint: http://{Config.MCP_SERVER_HOST}:{Config.MCP_SERVER_PORT}/mcp")
uvicorn.run(
app,
host=Config.MCP_SERVER_HOST,
port=Config.MCP_SERVER_PORT,
log_level="info"
)
if __name__ == "__main__":
main()
Reference in a new issue View git blame Copy permalink