refactor: Remove all OpenAI dependencies - 100% local AI

- Remove OPENAI_API_KEY from docker-compose.yml and CI workflow
- Delete USE_MOCK_OPENAI flag from Config class
- Update is_ai_enabled() to check for local model services
- Replace OpenAI references in env_manager with local model checks
- Update gdrive_real.py to use LM Studio for embeddings instead of OpenAI
- Delete obsolete test_openai_client.py
- Update CI to use local model URLs instead of API keys

The project now runs entirely on local models (LM Studio, CLIP, LLaVA) with no cloud dependencies or API keys required.

Author: raold

.github/workflows/ci.yml

@@ -34,8 +34,8 @@ jobs:
     - name: Run tests
       env:
         USE_MOCK_DB: "true"
-        OPENAI_API_KEY: "test-key"
-        ANTHROPIC_API_KEY: "test-key"
+        LM_STUDIO_URL: "http://localhost:1234"
+        CLIP_SERVICE_URL: "http://localhost:8002"
       run: |
         python -m pytest tests/unit/test_basic_functionality.py tests/unit/test_basic_modules.py tests/unit/test_factory.py -v --tb=short
     

app/config.py

@@ -61,7 +61,6 @@ class Config:
     # Feature Flags
     # NO MOCKS - PostgreSQL ONLY
     USE_MOCK_DATABASE: bool = False
-    USE_MOCK_OPENAI: bool = False
     FEATURE_SESSIONS_ENABLED: bool = env.get_bool("FEATURE_SESSIONS_ENABLED", True)
     FEATURE_ATTACHMENTS_ENABLED: bool = env.get_bool("FEATURE_ATTACHMENTS_ENABLED", True)
     ENABLE_TELEMETRY: bool = env.get_bool("ENABLE_TELEMETRY", False)
@@ -115,8 +114,9 @@ def get_summary(cls) -> dict:
 
     @classmethod
     def is_ai_enabled(cls) -> bool:
-        """Check if AI features are enabled."""
-        return bool(cls.OPENAI_API_KEY) or cls.USE_MOCK_OPENAI
+        """Check if AI features are enabled (local models)."""
+        # AI is always enabled with local models - no API keys needed!
+        return bool(cls.LM_STUDIO_URL or cls.CLIP_SERVICE_URL or cls.LLAVA_SERVICE_URL)
 
     @classmethod
     def is_database_configured(cls) -> bool:

app/core/env_manager.py

@@ -37,8 +37,6 @@ class EnvManager:
 
     # Sensitive keys that should be masked in logs
     SENSITIVE_KEYS = {
-        "OPENAI_API_KEY",
-        "ANTHROPIC_API_KEY",
         "JWT_SECRET_KEY",
         "DATABASE_URL",
         "POSTGRES_PASSWORD",
@@ -47,6 +45,8 @@ class EnvManager:
         "SENTRY_DSN",
         "AWS_SECRET_KEY",
         "AWS_ACCESS_KEY_ID",
+        "GOOGLE_CLIENT_SECRET",
+        "CIPHER_API_KEY",
     }
 
     def __init__(self, env_file: Path | None = None) -> None:
@@ -123,9 +123,9 @@ def _validate_required(self) -> None:
             if self.get("JWT_SECRET_KEY", "").endswith("change-in-production"):
                 raise ValueError("JWT_SECRET_KEY must be changed for production")
 
-        # Check OpenAI key if not using mocks
-        if not self.get_bool("USE_MOCK_OPENAI") and not self.get("OPENAI_API_KEY"):
-            logger.warning("OPENAI_API_KEY not set, AI features will be limited")
+        # Check local model services
+        if not self.get("LM_STUDIO_URL") and not self.get("CLIP_SERVICE_URL"):
+            logger.warning("Local model services not configured, AI features may be limited")
 
         # Validate required variables
         missing = [var for var in required if not os.getenv(var)]
@@ -307,15 +307,14 @@ def get_config_summary(self) -> dict[str, Any]:
         return {
             "environment": self.environment.value,
             "database_configured": bool(self.get("DATABASE_URL") or self.get("POSTGRES_DB")),
-            "openai_configured": bool(self.get("OPENAI_API_KEY")),
+            "local_models_configured": bool(self.get("LM_STUDIO_URL") or self.get("CLIP_SERVICE_URL")),
             "redis_configured": bool(self.get("REDIS_URL")),
             "debug_mode": self.get_bool("DEBUG"),
             "host": self.get("HOST", "127.0.0.1"),
             "port": self.get_int("PORT", 8000),
             "log_level": self.get("LOG_LEVEL", "INFO"),
             "features": {
                 "mock_database": self.get_bool("USE_MOCK_DATABASE"),
-                "mock_openai": self.get_bool("USE_MOCK_OPENAI"),
                 "sessions": self.get_bool("FEATURE_SESSIONS_ENABLED", True),
                 "attachments": self.get_bool("FEATURE_ATTACHMENTS_ENABLED", True),
             },
@@ -344,8 +343,8 @@ def validate_production_ready(self) -> list[str]:
         if self.get("HOST") == "0.0.0.0":
             issues.append("HOST is set to 0.0.0.0 (security risk)")
 
-        if not self.get("OPENAI_API_KEY") and not self.get_bool("USE_MOCK_OPENAI"):
-            issues.append("No OpenAI API key configured")
+        if not self.get("LM_STUDIO_URL") and not self.get("CLIP_SERVICE_URL"):
+            issues.append("No local model services configured")
 
         if self.get_bool("USE_MOCK_DATABASE"):
             issues.append("Mock database is enabled")

app/routes/gdrive_real.py

@@ -13,13 +13,9 @@
 from app.services.memory_service_postgres import MemoryServicePostgres
 from app.utils.logging_config import get_logger
 
-# Import OpenAI for embeddings
-try:
-    import openai
-
-    OPENAI_AVAILABLE = True
-except ImportError:
-    OPENAI_AVAILABLE = False
+# Local model configuration
+LM_STUDIO_AVAILABLE = bool(os.getenv("LM_STUDIO_URL"))
+CLIP_SERVICE_AVAILABLE = bool(os.getenv("CLIP_SERVICE_URL"))
 
 logger = get_logger(__name__)
 router = APIRouter()
@@ -131,22 +127,26 @@ async def sync_file(
         if not file_info:
             raise HTTPException(status_code=404, detail="File not found")
 
-        # Generate embeddings if OpenAI is available
+        # Generate embeddings using local models
         embeddings = None
-        if (
-            OPENAI_AVAILABLE
-            and os.getenv("OPENAI_API_KEY")
-            and os.getenv("OPENAI_API_KEY") != "sk-mock-key-for-testing-only"
-        ):
+        if LM_STUDIO_AVAILABLE:
             try:
-                openai.api_key = os.getenv("OPENAI_API_KEY")
-                response = await openai.Embedding.acreate(
-                    model="text-embedding-ada-002",
-                    input=content[:8000],  # Limit to 8000 chars for embedding
-                )
-                embeddings = response["data"][0]["embedding"]
+                # Use LM Studio for text embeddings (Nomic)
+                import aiohttp
+                async with aiohttp.ClientSession() as session:
+                    payload = {
+                        "model": "text-embedding-nomic-embed-text-v1.5",
+                        "input": content[:8000],  # Limit to 8000 chars for embedding
+                    }
+                    async with session.post(
+                        f"{os.getenv('LM_STUDIO_URL')}/embeddings",
+                        json=payload,
+                    ) as response:
+                        if response.status == 200:
+                            result = await response.json()
+                            embeddings = result["data"][0]["embedding"]
             except Exception as e:
-                logger.warning(f"Could not generate embeddings: {e}")
+                logger.warning(f"Could not generate embeddings with LM Studio: {e}")
 
         # Create memory in PostgreSQL
         memory_data = {

docker-compose.yml

@@ -15,7 +15,6 @@ services:
     environment:
       - DATABASE_URL=postgresql://secondbrain:changeme@postgres:5432/secondbrain
       - ENVIRONMENT=development
-      - OPENAI_API_KEY=${OPENAI_API_KEY}
     volumes:
       - .:/app:rw
       - /app/.venv  # Exclude .venv from mount