@chimerai/cli 0.2.73

package/dist/templates/ai-service.js

@@ -0,0 +1,2202 @@
+"use strict";
+/**
+ * AI Service Template Generators
+ *
+ * Generates Python service files for the modular AI-Service.
+ * Python files are embedded as string literals (same pattern as other CLI templates).
+ *
+ * Modules:
+ *   core      — main.py, config.py, provider_client.py (always included)
+ *   chat      — chat_service.py, model_service.py, moderation_service.py
+ *   rag       — rag_service.py, vector_store.py, embedding_service.py
+ *   guardrails — guardrails_service.py
+ *   tools     — services/tools/*.py (individually selectable)
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_INFO = void 0;
+exports.readAiManifest = readAiManifest;
+exports.writeAiManifest = writeAiManifest;
+exports.generateProviderClient = generateProviderClient;
+exports.generateServicesInit = generateServicesInit;
+exports.generateChatService = generateChatService;
+exports.generateModelService = generateModelService;
+exports.generateModerationService = generateModerationService;
+exports.generateEmbeddingService = generateEmbeddingService;
+exports.generateFileExtractor = generateFileExtractor;
+exports.generateRagService = generateRagService;
+exports.generateVectorStore = generateVectorStore;
+exports.generateGuardrailsService = generateGuardrailsService;
+exports.generateAiServiceMain = generateAiServiceMain;
+exports.generateAiServiceConfig = generateAiServiceConfig;
+exports.generateAiServiceModels = generateAiServiceModels;
+exports.generateAiServiceRequirements = generateAiServiceRequirements;
+exports.generateAiServiceDockerfile = generateAiServiceDockerfile;
+exports.generateAiServiceReadme = generateAiServiceReadme;
+exports.generateDockerComposeAiService = generateDockerComposeAiService;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+// ============================================================================
+// Tool Metadata (used by add command for interactive menu)
+// ============================================================================
+exports.TOOL_INFO = {
+    web_tools: {
+        displayName: 'Web Search & Scraping',
+        description: 'DuckDuckGo search, web scraping',
+        dependencies: ['ddgs>=9.0.0', 'beautifulsoup4>=4.12.2', 'lxml>=5.0.0', 'markdownify>=0.12.1'],
+    },
+    document_tools: {
+        displayName: 'Document Processing',
+        description: 'PDF, DOCX, XLSX, PPTX extraction',
+        dependencies: [
+            'pdfplumber>=0.10.3',
+            'python-docx>=1.1.0',
+            'openpyxl>=3.1.2',
+            'python-pptx>=0.6.23',
+        ],
+    },
+    code_tools: {
+        displayName: 'Code Execution',
+        description: 'Sandboxed Python execution',
+        dependencies: ['RestrictedPython>=7.0'],
+    },
+    nlp_tools: {
+        displayName: 'NLP Toolkit',
+        description: 'Summarize, Sentiment, Extract, Classify, Q&A',
+        dependencies: ['tiktoken>=0.5.0'],
+    },
+    vision_tools: {
+        displayName: 'Vision / Image Analysis',
+        description: 'Image description via LLM',
+        dependencies: ['pillow>=10.2.0'],
+    },
+    google_sheets_tools: {
+        displayName: 'Google Sheets Integration',
+        description: 'Read, write, append, create',
+        dependencies: ['google-api-python-client>=2.111.0', 'google-auth>=2.25.2'],
+    },
+    airtable_tools: {
+        displayName: 'Airtable Integration',
+        description: 'CRUD operations',
+        dependencies: ['pyairtable>=2.3.3'],
+    },
+    deepl_tools: {
+        displayName: 'Translation (DeepL)',
+        description: 'Text & document translation',
+        dependencies: ['deepl>=1.20.0'],
+    },
+    webhook_tools: {
+        displayName: 'Webhooks',
+        description: 'n8n, Zapier, Make.com, Slack',
+        dependencies: [], // httpx already in core
+    },
+};
+// ============================================================================
+// Manifest Management
+// ============================================================================
+function readAiManifest(targetDir) {
+    const manifestPath = path_1.default.join(targetDir, 'services', 'ai', '.chimerai-ai');
+    if (!fs_extra_1.default.existsSync(manifestPath))
+        return null;
+    try {
+        return JSON.parse(fs_extra_1.default.readFileSync(manifestPath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function writeAiManifest(targetDir, manifest) {
+    const manifestPath = path_1.default.join(targetDir, 'services', 'ai', '.chimerai-ai');
+    fs_extra_1.default.ensureDirSync(path_1.default.dirname(manifestPath));
+    fs_extra_1.default.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+}
+// ============================================================================
+// Core: provider_client.py — 1:1 copy from monorepo
+// ============================================================================
+function generateProviderClient() {
+    return `"""
+Provider Client — Centralized provider resolution.
+Auto-generated by ChimerAI CLI. Based on chimerai-kickstart monorepo.
+"""
+
+import time
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional
+import httpx
+import structlog
+
+from config import settings
+
+logger = structlog.get_logger()
+
+
+@dataclass
+class ProviderModel:
+    id: str
+    name: str
+
+
+@dataclass
+class ProviderInfo:
+    id: str
+    name: str
+    type: str
+    api_key: Optional[str] = None
+    base_url: Optional[str] = None
+    is_default: bool = False
+    is_active: bool = True
+    models: List[ProviderModel] = field(default_factory=list)
+
+
+class ProviderClient:
+    """
+    Client that fetches provider configuration from the Frontend Internal API.
+
+    Caches results for 5 minutes to avoid hitting the Frontend on every request.
+    Falls back gracefully to environment-based keys if the Frontend API is
+    unavailable (e.g. during local development without the full stack).
+    """
+
+    CACHE_TTL = 300  # 5 minutes
+
+    def __init__(self):
+        self._client: Optional[httpx.AsyncClient] = None
+        self._cache: Dict[str, ProviderInfo] = {}
+        self._all_providers: Optional[List[ProviderInfo]] = None
+        self._cache_timestamp: float = 0
+        self._available: Optional[bool] = None
+
+    @property
+    def client(self) -> httpx.AsyncClient:
+        if self._client is None or self._client.is_closed:
+            self._client = httpx.AsyncClient(
+                base_url=settings.frontend_url,
+                headers={
+                    "Authorization": f"Bearer {settings.internal_api_token}",
+                    "Content-Type": "application/json",
+                },
+                timeout=10.0,
+            )
+        return self._client
+
+    def _cache_valid(self) -> bool:
+        return (time.time() - self._cache_timestamp) < self.CACHE_TTL
+
+    def invalidate_cache(self):
+        self._cache.clear()
+        self._all_providers = None
+        self._cache_timestamp = 0
+        self._available = None
+        logger.info("provider_cache_invalidated")
+
+    async def is_available(self) -> bool:
+        if self._available is not None and self._cache_valid():
+            return self._available
+
+        if not settings.internal_api_token:
+            self._available = False
+            return False
+
+        try:
+            resp = await self.client.get("/api/internal/providers")
+            self._available = resp.status_code == 200
+        except Exception:
+            self._available = False
+
+        return self._available
+
+    async def get_all_providers(self) -> List[ProviderInfo]:
+        if self._all_providers is not None and self._cache_valid():
+            return self._all_providers
+
+        try:
+            resp = await self.client.get("/api/internal/providers")
+            resp.raise_for_status()
+            data = resp.json()
+
+            providers = []
+            for p in data:
+                provider = ProviderInfo(
+                    id=p["id"],
+                    name=p["name"],
+                    type=p.get("type", "openai"),
+                    api_key=p.get("apiKey") or p.get("api_key"),
+                    base_url=p.get("baseUrl") or p.get("base_url"),
+                    is_default=p.get("isDefault", False),
+                    is_active=p.get("isActive", True),
+                    models=[
+                        ProviderModel(id=m["id"], name=m["name"])
+                        for m in p.get("models", [])
+                    ],
+                )
+                providers.append(provider)
+                self._cache[provider.id] = provider
+
+            self._all_providers = providers
+            self._cache_timestamp = time.time()
+            logger.info("providers_loaded", count=len(providers))
+            return providers
+
+        except Exception as e:
+            logger.warning("get_providers_failed", error=str(e))
+            return self._all_providers or []
+
+    async def get_provider(self, provider_id: str) -> Optional[ProviderInfo]:
+        if provider_id in self._cache and self._cache_valid():
+            return self._cache[provider_id]
+
+        try:
+            resp = await self.client.get(f"/api/internal/providers/{provider_id}")
+            resp.raise_for_status()
+            p = resp.json()
+
+            provider = ProviderInfo(
+                id=p["id"],
+                name=p["name"],
+                type=p.get("type", "openai"),
+                api_key=p.get("apiKey") or p.get("api_key"),
+                base_url=p.get("baseUrl") or p.get("base_url"),
+                is_default=p.get("isDefault", False),
+                is_active=p.get("isActive", True),
+            )
+            self._cache[provider_id] = provider
+            self._cache_timestamp = time.time()
+            return provider
+
+        except Exception as e:
+            logger.warning("get_provider_failed", provider_id=provider_id, error=str(e))
+            return self._cache.get(provider_id)
+
+    async def get_default_provider(self, provider_type: Optional[str] = None) -> Optional[ProviderInfo]:
+        providers = await self.get_all_providers()
+        for p in providers:
+            if p.is_default and p.is_active:
+                if provider_type is None or p.type == provider_type:
+                    return p
+        active = [p for p in providers if p.is_active]
+        if provider_type:
+            active = [p for p in active if p.type == provider_type]
+        return active[0] if active else None
+
+    async def get_api_key(self, provider_id: str) -> Optional[str]:
+        provider = await self.get_provider(provider_id)
+        return provider.api_key if provider else None
+
+    async def report_usage(
+        self,
+        provider_id: str,
+        user_id: str,
+        model: str,
+        prompt_tokens: int,
+        completion_tokens: int,
+        endpoint: str = "/api/chat",
+    ) -> None:
+        try:
+            await self.client.post(
+                f"/api/internal/providers/{provider_id}/usage",
+                json={
+                    "userId": user_id,
+                    "model": model,
+                    "promptTokens": prompt_tokens,
+                    "completionTokens": completion_tokens,
+                    "endpoint": endpoint,
+                },
+            )
+        except Exception as e:
+            logger.warning("report_usage_failed", error=str(e))
+
+    async def close(self):
+        if self._client and not self._client.is_closed:
+            await self._client.aclose()
+            logger.info("provider_client_closed")
+
+
+provider_client = ProviderClient()
+`;
+}
+// ============================================================================
+// Core: services/__init__.py
+// ============================================================================
+function generateServicesInit() {
+    return `# Services package — Auto-generated by ChimerAI CLI
+`;
+}
+// ============================================================================
+// Chat Module: chat_service.py
+// ============================================================================
+function generateChatService() {
+    return `"""Chat completion service using LiteLLM. Auto-generated by ChimerAI CLI."""
+
+import json
+import time
+import uuid
+from typing import AsyncIterator, Optional
+import litellm
+from litellm import acompletion
+import structlog
+
+from models import (
+    ChatCompletionRequest,
+    ChatCompletionResponse,
+    ChatCompletionChoice,
+    ChatCompletionChunk,
+    ChatCompletionChunkChoice,
+    DeltaMessage,
+    Usage,
+    ChatMessage,
+)
+from config import settings
+from provider_client import provider_client
+
+logger = structlog.get_logger()
+
+litellm.set_verbose = False
+litellm.drop_params = True
+
+
+class ChatService:
+    """Service for handling chat completions using LiteLLM."""
+
+    async def _resolve_provider_kwargs(
+        self,
+        provider_id: Optional[str] = None,
+        model: Optional[str] = None,
+    ) -> dict:
+        kwargs: dict = {}
+
+        if provider_id:
+            provider = await provider_client.get_provider(provider_id)
+            if provider:
+                if provider.api_key:
+                    kwargs["api_key"] = provider.api_key
+                if provider.base_url:
+                    kwargs["api_base"] = provider.base_url
+                return kwargs
+
+        if await provider_client.is_available():
+            default = await provider_client.get_default_provider()
+            if default and default.api_key:
+                kwargs["api_key"] = default.api_key
+                if default.base_url:
+                    kwargs["api_base"] = default.base_url
+                return kwargs
+
+        return kwargs
+
+    async def create_completion(
+        self,
+        request: ChatCompletionRequest,
+        provider_id: Optional[str] = None,
+        user_id: Optional[str] = None,
+    ) -> ChatCompletionResponse:
+        logger.info("chat_completion_request", model=request.model, stream=False)
+
+        try:
+            provider_kwargs = await self._resolve_provider_kwargs(
+                provider_id=provider_id, model=request.model,
+            )
+
+            messages = [
+                {"role": msg.role.value, "content": msg.content}
+                for msg in request.messages
+            ]
+
+            response = await acompletion(
+                model=request.model,
+                messages=messages,
+                temperature=request.temperature,
+                max_tokens=request.max_tokens,
+                top_p=request.top_p,
+                frequency_penalty=request.frequency_penalty,
+                presence_penalty=request.presence_penalty,
+                user=request.user,
+                stream=False,
+                **provider_kwargs,
+            )
+
+            result = ChatCompletionResponse(
+                id=response.id or f"chatcmpl-{uuid.uuid4().hex[:8]}",
+                object="chat.completion",
+                created=int(time.time()),
+                model=response.model,
+                choices=[
+                    ChatCompletionChoice(
+                        index=choice.index,
+                        message=ChatMessage(
+                            role=choice.message.role,
+                            content=choice.message.content or "",
+                        ),
+                        finish_reason=choice.finish_reason or "stop",
+                    )
+                    for choice in response.choices
+                ],
+                usage=Usage(
+                    prompt_tokens=response.usage.prompt_tokens,
+                    completion_tokens=response.usage.completion_tokens,
+                    total_tokens=response.usage.total_tokens,
+                ),
+            )
+
+            if provider_id and user_id:
+                await provider_client.report_usage(
+                    provider_id=provider_id,
+                    user_id=user_id,
+                    model=request.model,
+                    prompt_tokens=response.usage.prompt_tokens,
+                    completion_tokens=response.usage.completion_tokens,
+                    endpoint="/api/chat",
+                )
+
+            return result
+
+        except Exception as e:
+            logger.error("chat_completion_error", error=str(e))
+            raise
+
+    async def create_streaming_completion(
+        self,
+        request: ChatCompletionRequest,
+        provider_id: Optional[str] = None,
+        user_id: Optional[str] = None,
+    ) -> AsyncIterator[str]:
+        logger.info("chat_completion_request", model=request.model, stream=True)
+
+        try:
+            provider_kwargs = await self._resolve_provider_kwargs(
+                provider_id=provider_id, model=request.model,
+            )
+
+            messages = [
+                {"role": msg.role.value, "content": msg.content}
+                for msg in request.messages
+            ]
+
+            response = await acompletion(
+                model=request.model,
+                messages=messages,
+                temperature=request.temperature,
+                max_tokens=request.max_tokens,
+                top_p=request.top_p,
+                frequency_penalty=request.frequency_penalty,
+                presence_penalty=request.presence_penalty,
+                user=request.user,
+                stream=True,
+                **provider_kwargs,
+            )
+
+            total_prompt_tokens = 0
+            total_completion_tokens = 0
+
+            async for chunk in response:
+                if not chunk.choices:
+                    continue
+
+                choice = chunk.choices[0]
+
+                if hasattr(chunk, "usage") and chunk.usage:
+                    total_prompt_tokens = getattr(chunk.usage, "prompt_tokens", 0) or 0
+                    total_completion_tokens = getattr(chunk.usage, "completion_tokens", 0) or 0
+
+                chunk_response = ChatCompletionChunk(
+                    id=chunk.id or f"chatcmpl-{uuid.uuid4().hex[:8]}",
+                    object="chat.completion.chunk",
+                    created=int(time.time()),
+                    model=chunk.model,
+                    choices=[
+                        ChatCompletionChunkChoice(
+                            index=choice.index,
+                            delta=DeltaMessage(
+                                role=getattr(choice.delta, "role", None),
+                                content=getattr(choice.delta, "content", None),
+                            ),
+                            finish_reason=choice.finish_reason,
+                        )
+                    ],
+                )
+
+                yield f"data: {chunk_response.model_dump_json()}\\n\\n"
+
+            if provider_id and user_id and (total_prompt_tokens or total_completion_tokens):
+                await provider_client.report_usage(
+                    provider_id=provider_id,
+                    user_id=user_id,
+                    model=request.model,
+                    prompt_tokens=total_prompt_tokens,
+                    completion_tokens=total_completion_tokens,
+                    endpoint="/api/chat/stream",
+                )
+
+            yield "data: [DONE]\\n\\n"
+
+        except Exception as e:
+            logger.error("streaming_completion_error", error=str(e))
+            error_payload = json.dumps({"error": {"message": str(e), "type": "server_error"}})
+            yield f"data: {error_payload}\\n\\n"
+            yield "data: [DONE]\\n\\n"
+
+
+chat_service = ChatService()
+`;
+}
+// ============================================================================
+// Chat Module: model_service.py
+// ============================================================================
+function generateModelService() {
+    return `"""Model listing service. Auto-generated by ChimerAI CLI."""
+
+import time
+import structlog
+from typing import Optional
+
+from models import ModelsResponse, ModelInfo
+from provider_client import provider_client
+from config import settings
+
+logger = structlog.get_logger()
+
+# Fallback models when provider APIs are not reachable
+FALLBACK_MODELS = [
+    ModelInfo(id="gpt-4", object="model", created=0, owned_by="openai"),
+    ModelInfo(id="gpt-4-turbo-preview", object="model", created=0, owned_by="openai"),
+    ModelInfo(id="gpt-3.5-turbo", object="model", created=0, owned_by="openai"),
+    ModelInfo(id="claude-3-opus-20240229", object="model", created=0, owned_by="anthropic"),
+    ModelInfo(id="claude-3-sonnet-20240229", object="model", created=0, owned_by="anthropic"),
+    ModelInfo(id="text-embedding-ada-002", object="model", created=0, owned_by="openai"),
+]
+
+
+class ModelService:
+    """Service for listing available models with caching."""
+
+    def __init__(self, cache_ttl: int = 300):
+        self._cache: Optional[ModelsResponse] = None
+        self._cache_time: float = 0
+        self._cache_ttl = cache_ttl  # seconds (default 5 min)
+
+    def _is_cache_valid(self) -> bool:
+        return self._cache is not None and (time.time() - self._cache_time) < self._cache_ttl
+
+    async def list_models(self) -> ModelsResponse:
+        logger.info("list_models_request")
+
+        # Return cached result if valid
+        if self._is_cache_valid():
+            logger.debug("list_models_cache_hit")
+            return self._cache
+
+        try:
+            models: list[ModelInfo] = []
+
+            # Try to fetch models from centralized providers
+            if await provider_client.is_available():
+                providers = await provider_client.get_all_providers()
+                for provider in providers:
+                    try:
+                        # Each provider may expose a list of models
+                        if hasattr(provider, "models") and provider.models:
+                            for m in provider.models:
+                                model_id = m.get("id") or m.get("model_id") if isinstance(m, dict) else str(m)
+                                if model_id:
+                                    models.append(ModelInfo(
+                                        id=model_id,
+                                        object="model",
+                                        created=int(time.time()),
+                                        owned_by=provider.name or "unknown",
+                                    ))
+                    except Exception as exc:
+                        logger.warning("provider_models_error", provider=provider.name, error=str(exc))
+
+            # Try OpenAI API directly as additional source
+            if settings.openai_api_key:
+                try:
+                    from openai import AsyncOpenAI
+                    client = AsyncOpenAI(api_key=settings.openai_api_key)
+                    openai_models = await client.models.list()
+                    for m in openai_models.data:
+                        if not any(existing.id == m.id for existing in models):
+                            models.append(ModelInfo(
+                                id=m.id,
+                                object="model",
+                                created=m.created or int(time.time()),
+                                owned_by=m.owned_by or "openai",
+                            ))
+                except Exception as exc:
+                    logger.warning("openai_models_fetch_error", error=str(exc))
+
+            # Fallback if no dynamic models found
+            if not models:
+                logger.info("list_models_fallback")
+                models = list(FALLBACK_MODELS)
+
+            result = ModelsResponse(object="list", data=models)
+
+            # Cache the result
+            self._cache = result
+            self._cache_time = time.time()
+
+            logger.info("list_models_success", count=len(models))
+            return result
+
+        except Exception as e:
+            logger.error("list_models_error", error=str(e))
+            # Return fallback on error
+            return ModelsResponse(object="list", data=list(FALLBACK_MODELS))
+
+
+model_service = ModelService()
+`;
+}
+// ============================================================================
+// Chat Module: moderation_service.py
+// ============================================================================
+function generateModerationService() {
+    return `"""Content moderation service using OpenAI. Auto-generated by ChimerAI CLI."""
+
+import uuid
+from typing import Optional
+from openai import AsyncOpenAI
+import structlog
+
+from models import (
+    ModerationRequest,
+    ModerationResponse,
+    ModerationResult,
+    ModerationCategories,
+    ModerationScores,
+)
+from config import settings
+from provider_client import provider_client
+
+logger = structlog.get_logger()
+
+
+class ModerationService:
+    """Content moderation using OpenAI moderation API."""
+
+    async def _get_client(self, provider_id: Optional[str] = None) -> AsyncOpenAI:
+        if provider_id:
+            provider = await provider_client.get_provider(provider_id)
+            if provider and provider.api_key:
+                return AsyncOpenAI(api_key=provider.api_key)
+
+        if await provider_client.is_available():
+            default = await provider_client.get_default_provider("openai")
+            if default and default.api_key:
+                return AsyncOpenAI(api_key=default.api_key)
+
+        api_key = settings.openai_api_key
+        if not api_key:
+            raise ValueError(
+                "No OpenAI API key available for moderation. "
+                "Configure an OpenAI provider at /providers or set OPENAI_API_KEY."
+            )
+        return AsyncOpenAI(api_key=api_key)
+
+    async def moderate_content(
+        self,
+        request: ModerationRequest,
+        provider_id: Optional[str] = None,
+        user_id: Optional[str] = None,
+    ) -> ModerationResponse:
+        logger.info("moderation_request", model=request.model)
+
+        try:
+            client = await self._get_client(provider_id=provider_id)
+
+            if isinstance(request.input, str):
+                inputs = [request.input]
+            else:
+                inputs = request.input
+
+            response = await client.moderations.create(
+                input=inputs,
+                model=request.model or "omni-moderation-latest",
+            )
+
+            results = []
+            for result in response.results:
+                results.append(
+                    ModerationResult(
+                        flagged=result.flagged,
+                        categories=ModerationCategories(
+                            hate=result.categories.hate,
+                            hate_threatening=result.categories.hate_threatening,
+                            harassment=result.categories.harassment,
+                            harassment_threatening=result.categories.harassment_threatening,
+                            self_harm=result.categories.self_harm,
+                            self_harm_intent=result.categories.self_harm_intent,
+                            self_harm_instructions=result.categories.self_harm_instructions,
+                            sexual=result.categories.sexual,
+                            sexual_minors=result.categories.sexual_minors,
+                            violence=result.categories.violence,
+                            violence_graphic=result.categories.violence_graphic,
+                        ),
+                        category_scores=ModerationScores(
+                            hate=result.category_scores.hate,
+                            hate_threatening=result.category_scores.hate_threatening,
+                            harassment=result.category_scores.harassment,
+                            harassment_threatening=result.category_scores.harassment_threatening,
+                            self_harm=result.category_scores.self_harm,
+                            self_harm_intent=result.category_scores.self_harm_intent,
+                            self_harm_instructions=result.category_scores.self_harm_instructions,
+                            sexual=result.category_scores.sexual,
+                            sexual_minors=result.category_scores.sexual_minors,
+                            violence=result.category_scores.violence,
+                            violence_graphic=result.category_scores.violence_graphic,
+                        ),
+                    )
+                )
+
+            return ModerationResponse(
+                id=f"modr-{uuid.uuid4().hex[:8]}",
+                model=request.model or "omni-moderation-latest",
+                results=results,
+            )
+
+        except ValueError:
+            raise
+        except Exception as e:
+            logger.error("moderation_error", error=str(e))
+            raise
+
+
+moderation_service = ModerationService()
+`;
+}
+// ============================================================================
+// RAG Module: embedding_service.py
+// ============================================================================
+function generateEmbeddingService() {
+    return `"""Embedding generation service using LiteLLM. Auto-generated by ChimerAI CLI."""
+
+from typing import Optional
+from litellm import aembedding
+import structlog
+
+from models import (
+    EmbeddingRequest,
+    EmbeddingResponse,
+    EmbeddingData,
+    EmbeddingUsage,
+)
+from config import settings
+from provider_client import provider_client
+
+logger = structlog.get_logger()
+
+
+class EmbeddingService:
+    """Service for generating embeddings using LiteLLM."""
+
+    async def _resolve_provider_kwargs(self, provider_id: Optional[str] = None) -> dict:
+        kwargs: dict = {}
+
+        if provider_id:
+            provider = await provider_client.get_provider(provider_id)
+            if provider:
+                if provider.api_key:
+                    kwargs["api_key"] = provider.api_key
+                if provider.base_url:
+                    kwargs["api_base"] = provider.base_url
+                return kwargs
+
+        if await provider_client.is_available():
+            default = await provider_client.get_default_provider()
+            if default and default.api_key:
+                kwargs["api_key"] = default.api_key
+                if default.base_url:
+                    kwargs["api_base"] = default.base_url
+                return kwargs
+
+        return kwargs
+
+    async def create_embeddings(
+        self,
+        request: EmbeddingRequest,
+        provider_id: Optional[str] = None,
+        user_id: Optional[str] = None,
+    ) -> EmbeddingResponse:
+        logger.info("embedding_request", model=request.model)
+
+        try:
+            provider_kwargs = await self._resolve_provider_kwargs(provider_id=provider_id)
+
+            if isinstance(request.input, str):
+                inputs = [request.input]
+            else:
+                inputs = request.input
+
+            response = await aembedding(
+                model=request.model,
+                input=inputs,
+                user=request.user,
+                **provider_kwargs,
+            )
+
+            embeddings_data = [
+                EmbeddingData(
+                    object="embedding",
+                    embedding=emb.embedding if hasattr(emb, "embedding") else emb["embedding"],
+                    index=i,
+                )
+                for i, emb in enumerate(response.data)
+            ]
+
+            result = EmbeddingResponse(
+                object="list",
+                data=embeddings_data,
+                model=response.model,
+                usage=EmbeddingUsage(
+                    prompt_tokens=response.usage.prompt_tokens,
+                    total_tokens=response.usage.total_tokens,
+                ),
+            )
+
+            if provider_id and user_id:
+                await provider_client.report_usage(
+                    provider_id=provider_id,
+                    user_id=user_id,
+                    model=request.model,
+                    prompt_tokens=response.usage.prompt_tokens,
+                    completion_tokens=0,
+                    endpoint="/api/embeddings",
+                )
+
+            return result
+
+        except Exception as e:
+            logger.error("embedding_error", error=str(e))
+            raise
+
+
+embedding_service = EmbeddingService()
+`;
+}
+// ============================================================================
+// RAG Module: rag_service.py
+// ============================================================================
+function generateFileExtractor() {
+    return `"""File text extraction for RAG uploads. Auto-generated by ChimerAI CLI.
+
+Supported formats:
+- .txt, .md, .csv, .json, .log — plain text (UTF-8)
+- .pdf — via PyMuPDF (pymupdf)
+- .docx — via python-docx
+"""
+
+import io
+import structlog
+from pathlib import Path
+
+logger = structlog.get_logger()
+
+# Optional imports — graceful fallback
+try:
+    import fitz  # pymupdf
+    PDF_AVAILABLE = True
+except ImportError:
+    PDF_AVAILABLE = False
+    logger.warning("pymupdf not installed — PDF extraction disabled. Install with: pip install pymupdf")
+
+try:
+    from docx import Document as DocxDocument
+    DOCX_AVAILABLE = True
+except ImportError:
+    DOCX_AVAILABLE = False
+    logger.warning("python-docx not installed — DOCX extraction disabled. Install with: pip install python-docx")
+
+
+# Plain text extensions (read as UTF-8)
+TEXT_EXTENSIONS = {".txt", ".md", ".csv", ".json", ".log", ".xml", ".yaml", ".yml", ".html", ".htm", ".rst", ".py", ".js", ".ts"}
+
+
+def extract_text(file_bytes: bytes, filename: str) -> str:
+    """Extract text content from a file based on its extension.
+
+    Args:
+        file_bytes: Raw file content as bytes.
+        filename: Original filename (used to detect format).
+
+    Returns:
+        Extracted text content.
+
+    Raises:
+        ValueError: If the file format is not supported or extraction fails.
+    """
+    ext = Path(filename).suffix.lower()
+
+    if ext == ".pdf":
+        return _extract_pdf(file_bytes, filename)
+    elif ext == ".docx":
+        return _extract_docx(file_bytes, filename)
+    elif ext in TEXT_EXTENSIONS or not ext:
+        return _extract_text(file_bytes, filename)
+    else:
+        # Try as text, but warn
+        logger.warning("unknown_file_extension", filename=filename, extension=ext, fallback="text")
+        return _extract_text(file_bytes, filename)
+
+
+def _extract_pdf(file_bytes: bytes, filename: str) -> str:
+    """Extract text from PDF using PyMuPDF."""
+    if not PDF_AVAILABLE:
+        raise ValueError(
+            f"Cannot extract text from PDF '{filename}': pymupdf is not installed. "
+            f"Install with: pip install pymupdf"
+        )
+    try:
+        doc = fitz.open(stream=file_bytes, filetype="pdf")
+        pages = []
+        for page in doc:
+            text = page.get_text()
+            if text.strip():
+                pages.append(text)
+        doc.close()
+
+        if not pages:
+            raise ValueError(f"PDF '{filename}' contains no extractable text (possibly scanned/image-only).")
+
+        result = "\\n\\n".join(pages)
+        logger.info("pdf_extracted", filename=filename, pages=len(pages), chars=len(result))
+        return result
+    except ValueError:
+        raise
+    except Exception as e:
+        raise ValueError(f"Failed to extract text from PDF '{filename}': {e}")
+
+
+def _extract_docx(file_bytes: bytes, filename: str) -> str:
+    """Extract text from DOCX using python-docx."""
+    if not DOCX_AVAILABLE:
+        raise ValueError(
+            f"Cannot extract text from DOCX '{filename}': python-docx is not installed. "
+            f"Install with: pip install python-docx"
+        )
+    try:
+        doc = DocxDocument(io.BytesIO(file_bytes))
+        paragraphs = [p.text for p in doc.paragraphs if p.text.strip()]
+
+        if not paragraphs:
+            raise ValueError(f"DOCX '{filename}' contains no text content.")
+
+        result = "\\n\\n".join(paragraphs)
+        logger.info("docx_extracted", filename=filename, paragraphs=len(paragraphs), chars=len(result))
+        return result
+    except ValueError:
+        raise
+    except Exception as e:
+        raise ValueError(f"Failed to extract text from DOCX '{filename}': {e}")
+
+
+def _extract_text(file_bytes: bytes, filename: str) -> str:
+    """Read file as UTF-8 text."""
+    try:
+        text = file_bytes.decode("utf-8")
+        if not text.strip():
+            raise ValueError(f"File '{filename}' is empty or contains only whitespace.")
+        logger.info("text_extracted", filename=filename, chars=len(text))
+        return text
+    except UnicodeDecodeError:
+        # Try latin-1 as fallback
+        try:
+            text = file_bytes.decode("latin-1")
+            logger.warning("text_fallback_latin1", filename=filename)
+            return text
+        except Exception:
+            raise ValueError(f"File '{filename}' is not a valid text file (encoding not supported).")
+
+
+def get_supported_formats() -> dict:
+    """Return supported file formats and their availability."""
+    return {
+        "text": sorted(TEXT_EXTENSIONS),
+        "pdf": {".pdf"} if PDF_AVAILABLE else None,
+        "docx": {".docx"} if DOCX_AVAILABLE else None,
+        "pdf_available": PDF_AVAILABLE,
+        "docx_available": DOCX_AVAILABLE,
+    }
+`;
+}
+function generateRagService() {
+    return `"""RAG (Retrieval Augmented Generation) service. Auto-generated by ChimerAI CLI."""
+
+from typing import List, Optional
+import structlog
+
+from config import settings
+from services.vector_store import vector_store, FAISS_AVAILABLE
+from services.chat_service import chat_service
+from models import ChatCompletionRequest, ChatMessage, MessageRole
+
+logger = structlog.get_logger()
+
+
+class RAGService:
+    """Service for Retrieval Augmented Generation (RAG)."""
+
+    def _check_availability(self):
+        if not FAISS_AVAILABLE or vector_store is None:
+            raise RuntimeError(
+                "FAISS vector store is not available. "
+                "Install faiss-cpu: pip install faiss-cpu numpy"
+            )
+
+    async def add_documents(
+        self,
+        documents: List[str],
+        metadatas: Optional[List[dict]] = None,
+    ) -> dict:
+        try:
+            self._check_availability()
+            ids = await vector_store.add_texts(documents, metadatas)
+            logger.info("documents_added", count=len(ids))
+            return {
+                "status": "success",
+                "added": len(ids),
+                "ids": ids,
+                "total_vectors": vector_store.get_stats()["total_vectors"],
+            }
+        except Exception as e:
+            logger.error("add_documents_failed", error=str(e))
+            raise
+
+    async def search_documents(self, query: str, k: int = 4) -> List[dict]:
+        try:
+            self._check_availability()
+            results = await vector_store.similarity_search(query, k=k)
+            logger.info("documents_searched", query_length=len(query), results=len(results))
+            return results
+        except Exception as e:
+            logger.error("search_documents_failed", error=str(e))
+            raise
+
+    async def rag_chat(
+        self,
+        query: str,
+        model: Optional[str] = None,
+        k: int = 3,
+        temperature: float = 0.7,
+        max_tokens: Optional[int] = None,
+        provider_id: Optional[str] = None,
+        user_id: Optional[str] = None,
+    ) -> dict:
+        try:
+            self._check_availability()
+
+            relevant_docs = await vector_store.similarity_search(query, k=k)
+
+            context_parts = []
+            for i, doc in enumerate(relevant_docs, 1):
+                context_parts.append(f"[Document {i}]\\n{doc['text']}")
+
+            context = "\\n\\n".join(context_parts) if context_parts else "No relevant documents found."
+
+            system_message = f"""You are a helpful assistant. Use the following context to answer the user's question.
+If the context doesn't contain relevant information, say so and provide a general answer.
+
+Context:
+{context}"""
+
+            messages = [
+                ChatMessage(role=MessageRole.SYSTEM, content=system_message),
+                ChatMessage(role=MessageRole.USER, content=query),
+            ]
+
+            model = model or settings.default_chat_model
+
+            chat_request = ChatCompletionRequest(
+                model=model,
+                messages=messages,
+                temperature=temperature,
+                max_tokens=max_tokens,
+            )
+            response = await chat_service.create_completion(
+                chat_request,
+                provider_id=provider_id,
+                user_id=user_id,
+            )
+
+            response_dict = response.model_dump()
+
+            response_dict["rag_metadata"] = {
+                "retrieved_documents": len(relevant_docs),
+                "documents": [
+                    {
+                        "text": doc["text"][:200] + "..." if len(doc["text"]) > 200 else doc["text"],
+                        "score": doc["score"],
+                        "metadata": doc.get("metadata", {}),
+                    }
+                    for doc in relevant_docs
+                ],
+            }
+
+            logger.info("rag_chat_completed", query_length=len(query), docs_retrieved=len(relevant_docs))
+            return response_dict
+
+        except Exception as e:
+            logger.error("rag_chat_failed", error=str(e))
+            raise
+
+    def get_stats(self) -> dict:
+        self._check_availability()
+        return vector_store.get_stats()
+
+    def clear_store(self):
+        self._check_availability()
+        vector_store.clear()
+        return {"status": "success", "message": "Vector store cleared"}
+
+    async def delete_documents(self, document_ids: List[int]) -> dict:
+        try:
+            self._check_availability()
+            deleted = await vector_store.delete_by_ids(document_ids)
+            logger.info("documents_deleted", requested=len(document_ids), deleted=deleted)
+            return {
+                "status": "success",
+                "deleted": deleted,
+                "remaining_vectors": vector_store.get_stats()["total_vectors"],
+            }
+        except Exception as e:
+            logger.error("delete_documents_failed", error=str(e))
+            raise
+
+
+rag_service = RAGService()
+`;
+}
+// ============================================================================
+// RAG Module: vector_store.py
+// ============================================================================
+function generateVectorStore() {
+    return `"""FAISS-based vector store with chunking and LiteLLM embeddings. Auto-generated by ChimerAI CLI."""
+
+try:
+    import faiss
+    import numpy as np
+    FAISS_AVAILABLE = True
+except Exception as e:
+    FAISS_AVAILABLE = False
+    print(f"Warning: FAISS/Numpy not available: {e}")
+
+import pickle
+import os
+from typing import List, Dict, Any, Optional
+import litellm
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from config import settings
+import structlog
+
+logger = structlog.get_logger()
+
+
+class VectorStore:
+    """FAISS-based vector store for document embeddings and semantic search."""
+
+    def __init__(self, dimension: int = 1536, index_path: str = "data/faiss_index"):
+        if not FAISS_AVAILABLE:
+            raise RuntimeError("FAISS is not available. Please install faiss-cpu.")
+
+        self.dimension = dimension
+        self.index_path = index_path
+        self.metadata_path = f"{index_path}.metadata.pkl"
+
+        # Text splitter for chunking
+        self.text_splitter = RecursiveCharacterTextSplitter(
+            chunk_size=1000,
+            chunk_overlap=200,
+            length_function=len,
+            separators=["\\n\\n", "\\n", ". ", " ", ""],
+        )
+
+        self.index = None
+        self.metadata: List[Dict[str, Any]] = []
+        self._load_or_create_index()
+
+    def _load_or_create_index(self):
+        if os.path.exists(self.index_path) and os.path.exists(self.metadata_path):
+            try:
+                self.index = faiss.read_index(self.index_path)
+                with open(self.metadata_path, "rb") as f:
+                    self.metadata = pickle.load(f)
+                logger.info("faiss_index_loaded", num_vectors=self.index.ntotal)
+            except Exception as e:
+                logger.error("faiss_index_load_failed", error=str(e))
+                self._create_new_index()
+        else:
+            self._create_new_index()
+
+    def _create_new_index(self):
+        self.index = faiss.IndexFlatL2(self.dimension)
+        self.metadata = []
+        logger.info("faiss_index_created", dimension=self.dimension)
+
+    def save(self):
+        try:
+            os.makedirs(os.path.dirname(self.index_path), exist_ok=True)
+            faiss.write_index(self.index, self.index_path)
+            with open(self.metadata_path, "wb") as f:
+                pickle.dump(self.metadata, f)
+            logger.info("faiss_index_saved", num_vectors=self.index.ntotal)
+        except Exception as e:
+            logger.error("faiss_index_save_failed", error=str(e))
+            raise
+
+    async def add_texts(
+        self, texts: List[str], metadatas: Optional[List[Dict[str, Any]]] = None
+    ) -> List[int]:
+        if not texts:
+            return []
+
+        if metadatas is None:
+            metadatas = [{} for _ in texts]
+
+        # Split texts into chunks
+        all_chunks: List[str] = []
+        all_metadatas: List[Dict[str, Any]] = []
+
+        for i, text in enumerate(texts):
+            chunks = self.text_splitter.split_text(text)
+            if not chunks:
+                chunks = [text]
+
+            meta = metadatas[i] if i < len(metadatas) else {}
+            for j, chunk in enumerate(chunks):
+                all_chunks.append(chunk)
+                all_metadatas.append({
+                    **meta,
+                    "_chunk_index": j,
+                    "_chunk_total": len(chunks),
+                    "_source_doc_index": i,
+                })
+
+        embeddings = await self._generate_embeddings(all_chunks)
+        embeddings_array = np.array(embeddings, dtype=np.float32)
+
+        start_id = len(self.metadata)
+        self.index.add(embeddings_array)
+
+        for k, (chunk, metadata) in enumerate(zip(all_chunks, all_metadatas)):
+            self.metadata.append({"_system_id": start_id + k, "_system_text": chunk, **metadata})
+
+        self.save()
+        ids = list(range(start_id, start_id + len(all_chunks)))
+        logger.info("texts_added_to_index",
+                    documents=len(texts),
+                    chunks=len(all_chunks),
+                    total=self.index.ntotal)
+        return ids
+
+    async def delete_by_ids(self, ids: List[int]) -> int:
+        ids_set = set(ids)
+        remaining = [m for m in self.metadata if m["_system_id"] not in ids_set]
+
+        if len(remaining) == len(self.metadata):
+            return 0
+
+        deleted_count = len(self.metadata) - len(remaining)
+
+        self._create_new_index()
+        if remaining:
+            texts = [m["_system_text"] for m in remaining]
+            embeddings = await self._generate_embeddings(texts)
+            embeddings_array = np.array(embeddings, dtype=np.float32)
+            self.index.add(embeddings_array)
+            self.metadata = []
+            for k, m in enumerate(remaining):
+                new_meta = {key: val for key, val in m.items() if key != "_system_id"}
+                new_meta["_system_id"] = k
+                self.metadata.append(new_meta)
+
+        self.save()
+        logger.info("documents_deleted", deleted=deleted_count, remaining=self.index.ntotal)
+        return deleted_count
+
+    async def similarity_search(self, query: str, k: int = 4) -> List[Dict[str, Any]]:
+        if self.index.ntotal == 0:
+            return []
+
+        query_embeddings = await self._generate_embeddings([query])
+        query_vector = np.array(query_embeddings, dtype=np.float32)
+
+        k = min(k, self.index.ntotal)
+        distances, indices = self.index.search(query_vector, k)
+
+        results = []
+        for i, (distance, idx) in enumerate(zip(distances[0], indices[0])):
+            if idx < len(self.metadata):
+                stored = self.metadata[idx]
+                doc_id = stored.get("_system_id", idx)
+                text = stored.get("_system_text", "")
+                user_metadata = {
+                    k: v for k, v in stored.items() if not k.startswith("_system_")
+                }
+                similarity_score = 1.0 / (1.0 + float(distance))
+                results.append({
+                    "id": doc_id,
+                    "text": text,
+                    "score": similarity_score,
+                    "rank": i + 1,
+                    "metadata": user_metadata,
+                })
+
+        return results
+
+    async def _generate_embeddings(self, texts: List[str]) -> List[List[float]]:
+        try:
+            response = await litellm.aembedding(
+                model=settings.default_embedding_model,
+                input=texts,
+            )
+            embeddings = [
+                item["embedding"] if isinstance(item, dict) else item.embedding
+                for item in response.data
+            ]
+            logger.info("embeddings_generated",
+                        count=len(embeddings),
+                        model=settings.default_embedding_model)
+            return embeddings
+        except Exception as e:
+            logger.error("embedding_generation_failed", error=str(e))
+            raise
+
+    def get_stats(self) -> Dict[str, Any]:
+        return {
+            "total_vectors": self.index.ntotal,
+            "dimension": self.dimension,
+            "index_type": type(self.index).__name__,
+            "metadata_count": len(self.metadata),
+        }
+
+    def clear(self):
+        self._create_new_index()
+        self.save()
+        logger.info("faiss_index_cleared")
+
+
+if FAISS_AVAILABLE:
+    try:
+        vector_store = VectorStore(dimension=settings.embedding_dimension)
+    except Exception as e:
+        logger.warning(f"Failed to initialize vector store: {e}")
+        vector_store = None
+else:
+    vector_store = None
+`;
+}
+// ============================================================================
+// Guardrails Module: guardrails_service.py
+// NOTE: Backslashes in regex patterns are double-escaped for JS template literals.
+// ============================================================================
+function generateGuardrailsService() {
+    return `"""Guardrails and safety tools. Auto-generated by ChimerAI CLI."""
+
+from typing import Dict, Any, List, Optional
+import re
+import structlog
+
+logger = structlog.get_logger()
+
+
+class GuardrailsService:
+    """
+    Input/Output validation and safety checks.
+
+    Features:
+    - PII detection and redaction
+    - Toxicity filtering
+    - Prompt injection detection
+    - Output validation
+    """
+
+    def __init__(self):
+        self.pii_patterns = self._initialize_pii_patterns()
+        self.toxic_keywords = self._load_toxic_keywords()
+
+    def _initialize_pii_patterns(self) -> Dict[str, re.Pattern]:
+        return {
+            "email": re.compile(r'\\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Z|a-z]{2,}\\b'),
+            "phone": re.compile(r'\\b\\d{3}[-.]?\\d{3}[-.]?\\d{4}\\b'),
+            "ssn": re.compile(r'\\b\\d{3}-\\d{2}-\\d{4}\\b'),
+            "credit_card": re.compile(r'\\b\\d{4}[- ]?\\d{4}[- ]?\\d{4}[- ]?\\d{4}\\b'),
+            "ip_address": re.compile(r'\\b\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\b'),
+            "api_key": re.compile(r'\\b[A-Za-z0-9_-]{32,}\\b'),
+        }
+
+    def _load_toxic_keywords(self) -> List[str]:
+        return [
+            "kill", "murder", "violent", "attack", "threat", "assault", "abuse",
+            "torture", "harm", "hurt", "shoot", "stab", "destroy",
+            "hate", "hatred", "racist", "supremacy", "genocide",
+            "rape", "molest", "pedophile", "incest",
+            "suicide", "self harm",
+            "terrorist", "extremist", "radical", "bomb",
+        ]
+
+    async def detect_pii(self, text: str) -> Dict[str, Any]:
+        try:
+            detected = {}
+            for pii_type, pattern in self.pii_patterns.items():
+                matches = pattern.findall(text)
+                if matches:
+                    detected[pii_type] = {"count": len(matches), "samples": matches[:3]}
+
+            has_pii = len(detected) > 0
+            logger.info("pii_detection", has_pii=has_pii, types=list(detected.keys()))
+            return {"has_pii": has_pii, "detected": detected, "risk_level": "high" if has_pii else "low"}
+
+        except Exception as e:
+            logger.error("pii_detection_error", error=str(e))
+            raise
+
+    async def redact_pii(self, text: str, redaction_char: str = "\\u2588") -> Dict[str, Any]:
+        try:
+            redacted_text = text
+            changes = []
+            for pii_type, pattern in self.pii_patterns.items():
+                for match in pattern.finditer(text):
+                    original = match.group()
+                    replacement = redaction_char * len(original)
+                    redacted_text = redacted_text.replace(original, replacement)
+                    changes.append({"type": pii_type, "original": original, "position": match.span()})
+
+            logger.info("pii_redaction", changes_count=len(changes))
+            return {"redacted_text": redacted_text, "changes": changes, "redactions_count": len(changes)}
+
+        except Exception as e:
+            logger.error("pii_redaction_error", error=str(e))
+            raise
+
+    async def check_toxicity(self, text: str) -> Dict[str, Any]:
+        try:
+            text_lower = text.lower()
+            toxic_matches = [kw for kw in self.toxic_keywords if kw in text_lower]
+            toxicity_score = min(len(toxic_matches) / 10.0, 1.0)
+            is_toxic = toxicity_score > 0.3
+
+            logger.info("toxicity_check", is_toxic=is_toxic, score=toxicity_score)
+            return {
+                "is_toxic": is_toxic,
+                "toxicity_score": toxicity_score,
+                "matched_keywords": toxic_matches[:5],
+                "risk_level": "high" if toxicity_score > 0.7 else "medium" if toxicity_score > 0.3 else "low",
+            }
+
+        except Exception as e:
+            logger.error("toxicity_check_error", error=str(e))
+            raise
+
+    async def detect_prompt_injection(self, prompt: str) -> Dict[str, Any]:
+        try:
+            injection_patterns = [
+                r'ignore (previous|above|all) (instructions|prompts)',
+                r'you are (now|a) (?!assistant)',
+                r'(system|admin) (prompt|mode)',
+                r'<\\\\|im_start\\\\|>',
+                r'###\\\\s*system',
+                r'disregard',
+                r'forget (everything|all)',
+            ]
+
+            detected = []
+            prompt_lower = prompt.lower()
+            for pattern in injection_patterns:
+                if re.search(pattern, prompt_lower):
+                    detected.append(pattern)
+
+            is_injection = len(detected) > 0
+            logger.warning("prompt_injection_check", detected=is_injection)
+            return {
+                "is_injection": is_injection,
+                "confidence": len(detected) / len(injection_patterns),
+                "matched_patterns": detected,
+                "risk_level": "high" if is_injection else "low",
+            }
+
+        except Exception as e:
+            logger.error("injection_detection_error", error=str(e))
+            raise
+
+    async def validate_output(
+        self,
+        output: str,
+        max_length: Optional[int] = None,
+        required_elements: Optional[List[str]] = None,
+    ) -> Dict[str, Any]:
+        try:
+            issues = []
+
+            if max_length and len(output) > max_length:
+                issues.append(f"Output exceeds max length ({len(output)} > {max_length})")
+
+            if required_elements:
+                output_lower = output.lower()
+                missing = [el for el in required_elements if el.lower() not in output_lower]
+                if missing:
+                    issues.append(f"Missing required elements: {missing}")
+
+            pii_result = await self.detect_pii(output)
+            if pii_result["has_pii"]:
+                issues.append(f"Output contains PII: {list(pii_result['detected'].keys())}")
+
+            toxicity_result = await self.check_toxicity(output)
+            if toxicity_result["is_toxic"]:
+                issues.append(f"Output contains toxic content (score: {toxicity_result['toxicity_score']:.2f})")
+
+            is_valid = len(issues) == 0
+            logger.info("output_validation", is_valid=is_valid, issues_count=len(issues))
+            return {
+                "is_valid": is_valid,
+                "issues": issues,
+                "pii_detected": pii_result["has_pii"],
+                "toxicity_score": toxicity_result["toxicity_score"],
+            }
+
+        except Exception as e:
+            logger.error("output_validation_error", error=str(e))
+            raise
+
+    async def sanitize_input(self, text: str) -> str:
+        try:
+            sanitized = re.sub(r'[\\x00-\\x1f\\x7f-\\x9f]', '', text)
+            sanitized = re.sub(r'\\s+', ' ', sanitized)
+            max_length = 10_000
+            if len(sanitized) > max_length:
+                sanitized = sanitized[:max_length]
+                logger.warning("input_truncated", original_length=len(text))
+            return sanitized.strip()
+
+        except Exception as e:
+            logger.error("input_sanitization_error", error=str(e))
+            raise
+
+
+guardrails_service = GuardrailsService()
+`;
+}
+// ============================================================================
+// Dynamic Generators — main.py, config.py, models.py, requirements.txt, etc.
+// ============================================================================
+/**
+ * Generate main.py — conditional imports and router registration based on modules.
+ */
+function generateAiServiceMain(modules, tools = []) {
+    const hasChat = modules.includes('chat');
+    const hasRag = modules.includes('rag');
+    const hasGuardrails = modules.includes('guardrails');
+    const hasTools = tools.length > 0;
+    const imports = [];
+    const routers = [];
+    if (hasChat) {
+        imports.push('from routes.chat_routes import router as chat_router');
+        routers.push('app.include_router(chat_router)');
+    }
+    if (hasRag) {
+        imports.push('from routes.rag_routes import router as rag_router');
+        routers.push('app.include_router(rag_router)');
+    }
+    if (hasGuardrails) {
+        imports.push('from routes.guardrails_routes import router as guardrails_router');
+        routers.push('app.include_router(guardrails_router)');
+    }
+    if (hasTools) {
+        imports.push('from routes.tools_routes import router as tools_router');
+        routers.push('app.include_router(tools_router)');
+    }
+    return `"""ChimerAI AI Service — Auto-generated by ChimerAI CLI."""
+
+import os
+from contextlib import asynccontextmanager
+from fastapi import FastAPI, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+import structlog
+import uvicorn
+
+from config import settings
+from provider_client import provider_client
+
+${imports.join('\n')}
+
+structlog.configure(
+    processors=[
+        structlog.processors.TimeStamper(fmt="iso"),
+        structlog.processors.JSONRenderer(),
+    ]
+)
+
+logger = structlog.get_logger()
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Startup and shutdown logic."""
+    logger.info("ai_service_starting", port=settings.port)
+
+    # Set OpenAI key as env fallback for LiteLLM
+    if settings.openai_api_key:
+        os.environ["OPENAI_API_KEY"] = settings.openai_api_key
+
+    # Try to connect to Frontend Internal API for centralized providers
+    provider_mode = "env_fallback"
+    if settings.internal_api_token:
+        try:
+            available = await provider_client.is_available()
+            if available:
+                providers = await provider_client.get_all_providers()
+                provider_mode = "centralized"
+                logger.info("provider_client_connected", providers_loaded=len(providers))
+
+                default = await provider_client.get_default_provider()
+                if default and default.api_key:
+                    os.environ["OPENAI_API_KEY"] = default.api_key
+                    logger.info("default_provider_set", provider_name=default.name)
+            else:
+                logger.warning("provider_client_unavailable")
+        except Exception as exc:
+            logger.warning("provider_client_error", error=str(exc))
+
+    logger.info("ai_service_started", provider_mode=provider_mode)
+    yield
+
+    await provider_client.close()
+    logger.info("ai_service_stopped")
+
+
+app = FastAPI(
+    title="ChimerAI AI Service",
+    version="1.0.0",
+    lifespan=lifespan,
+)
+
+# CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=[
+        settings.frontend_url,
+        "http://localhost:3000",
+        "http://localhost:3001",
+    ],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# Bearer token auth middleware
+@app.middleware("http")
+async def verify_service_token(request: Request, call_next):
+    """Verify INTERNAL_SERVICE_TOKEN on all non-health endpoints."""
+    # Skip auth for health check and docs
+    if request.url.path in ("/health", "/docs", "/openapi.json"):
+        return await call_next(request)
+
+    expected_token = settings.internal_service_token
+    if not expected_token:
+        # No token configured — skip auth (development mode)
+        return await call_next(request)
+
+    auth_header = request.headers.get("authorization", "")
+    if not auth_header.startswith("Bearer "):
+        return JSONResponse(
+            status_code=401,
+            content={"detail": "Missing or invalid Authorization header"},
+        )
+
+    token = auth_header[7:]
+    if token != expected_token:
+        return JSONResponse(
+            status_code=401,
+            content={"detail": "Invalid service token"},
+        )
+
+    return await call_next(request)
+
+
+# Register routers
+${routers.join('\n')}
+
+
+# Internal endpoints
+@app.post("/api/internal/invalidate-cache")
+async def invalidate_cache():
+    """Cache invalidation webhook from Frontend."""
+    provider_client.invalidate_cache()
+    return {"status": "ok"}
+
+
+@app.get("/health")
+async def health():
+    """Health check endpoint."""
+    provider_available = await provider_client.is_available()
+    return {
+        "status": "healthy",
+        "service": "chimerai-ai-service",
+        "provider_mode": "centralized" if provider_available else "env_fallback",
+    }
+
+
+if __name__ == "__main__":
+    uvicorn.run(app, host=settings.host, port=settings.port, log_level="info")
+`;
+}
+/**
+ * Generate config.py — conditional RAG settings.
+ */
+function generateAiServiceConfig(modules) {
+    const hasRag = modules.includes('rag');
+    const ragFields = hasRag
+        ? `
+    # RAG Settings
+    default_embedding_model: str = "text-embedding-ada-002"
+    embedding_dimension: int = 1536
+`
+        : '';
+    return `"""ChimerAI AI Service Configuration. Auto-generated by ChimerAI CLI."""
+
+from pydantic_settings import BaseSettings
+from typing import Optional
+
+
+class Settings(BaseSettings):
+    # Service
+    host: str = "0.0.0.0"
+    port: int = 8002
+
+    # Provider Management (Frontend Internal API)
+    frontend_url: str = "http://localhost:3000"
+    internal_api_token: Optional[str] = None
+    internal_service_token: Optional[str] = None
+
+    # API Keys (Fallback)
+    openai_api_key: Optional[str] = None
+
+    # Caching
+    redis_url: str = "redis://localhost:6379"
+    redis_enabled: bool = False
+${ragFields}
+    # Default Model
+    default_chat_model: str = "gpt-3.5-turbo"
+
+    class Config:
+        env_file = ".env"
+        extra = "ignore"
+
+
+settings = Settings()
+`;
+}
+/**
+ * Generate models.py — only Pydantic models needed by installed modules.
+ */
+function generateAiServiceModels(modules) {
+    const hasChat = modules.includes('chat');
+    const hasRag = modules.includes('rag');
+    // Core models (always needed if chat is installed)
+    const chatModels = hasChat
+        ? `
+# ============================================================================
+# Chat Models
+# ============================================================================
+
+class MessageRole(str, Enum):
+    SYSTEM = "system"
+    USER = "user"
+    ASSISTANT = "assistant"
+
+
+class ChatMessage(BaseModel):
+    role: MessageRole
+    content: str
+
+
+class ChatCompletionRequest(BaseModel):
+    model: str
+    messages: List[ChatMessage]
+    temperature: Optional[float] = 0.7
+    max_tokens: Optional[int] = None
+    top_p: Optional[float] = 1.0
+    frequency_penalty: Optional[float] = 0.0
+    presence_penalty: Optional[float] = 0.0
+    stream: Optional[bool] = False
+    user: Optional[str] = None
+    provider_id: Optional[str] = None
+    user_id: Optional[str] = None
+
+
+class ChatCompletionChoice(BaseModel):
+    index: int
+    message: ChatMessage
+    finish_reason: str
+
+
+class Usage(BaseModel):
+    prompt_tokens: int
+    completion_tokens: int
+    total_tokens: int
+
+
+class ChatCompletionResponse(BaseModel):
+    id: str
+    object: str = "chat.completion"
+    created: int
+    model: str
+    choices: List[ChatCompletionChoice]
+    usage: Usage
+
+
+class DeltaMessage(BaseModel):
+    role: Optional[MessageRole] = None
+    content: Optional[str] = None
+
+
+class ChatCompletionChunkChoice(BaseModel):
+    index: int
+    delta: DeltaMessage
+    finish_reason: Optional[str] = None
+
+
+class ChatCompletionChunk(BaseModel):
+    id: str
+    object: str = "chat.completion.chunk"
+    created: int
+    model: str
+    choices: List[ChatCompletionChunkChoice]
+
+
+class ModelInfo(BaseModel):
+    id: str
+    object: str = "model"
+    created: int
+    owned_by: str
+
+
+class ModelsResponse(BaseModel):
+    object: str = "list"
+    data: List[ModelInfo]
+
+
+class ModerationRequest(BaseModel):
+    input: Union[str, List[str]]
+    model: Optional[str] = "omni-moderation-latest"
+    provider_id: Optional[str] = None
+    user_id: Optional[str] = None
+
+
+class ModerationCategories(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    hate: bool
+    hate_threatening: bool = Field(alias="hate/threatening")
+    harassment: bool
+    harassment_threatening: bool = Field(alias="harassment/threatening")
+    self_harm: bool = Field(alias="self-harm")
+    self_harm_intent: bool = Field(alias="self-harm/intent")
+    self_harm_instructions: bool = Field(alias="self-harm/instructions")
+    sexual: bool
+    sexual_minors: bool = Field(alias="sexual/minors")
+    violence: bool
+    violence_graphic: bool = Field(alias="violence/graphic")
+
+
+class ModerationScores(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    hate: float
+    hate_threatening: float = Field(alias="hate/threatening")
+    harassment: float
+    harassment_threatening: float = Field(alias="harassment/threatening")
+    self_harm: float = Field(alias="self-harm")
+    self_harm_intent: float = Field(alias="self-harm/intent")
+    self_harm_instructions: float = Field(alias="self-harm/instructions")
+    sexual: float
+    sexual_minors: float = Field(alias="sexual/minors")
+    violence: float
+    violence_graphic: float = Field(alias="violence/graphic")
+
+
+class ModerationResult(BaseModel):
+    flagged: bool
+    categories: ModerationCategories
+    category_scores: ModerationScores
+
+
+class ModerationResponse(BaseModel):
+    id: str
+    model: str
+    results: List[ModerationResult]
+`
+        : '';
+    const embeddingModels = hasRag || hasChat
+        ? `
+# ============================================================================
+# Embedding Models
+# ============================================================================
+
+class EmbeddingRequest(BaseModel):
+    model: str
+    input: Union[str, List[str]]
+    user: Optional[str] = None
+    provider_id: Optional[str] = None
+    user_id: Optional[str] = None
+
+
+class EmbeddingData(BaseModel):
+    object: str = "embedding"
+    embedding: List[float]
+    index: int
+
+
+class EmbeddingUsage(BaseModel):
+    prompt_tokens: int
+    total_tokens: int
+
+
+class EmbeddingResponse(BaseModel):
+    object: str = "list"
+    data: List[EmbeddingData]
+    model: str
+    usage: EmbeddingUsage
+`
+        : '';
+    const ragModels = hasRag
+        ? `
+# ============================================================================
+# RAG Models
+# ============================================================================
+
+class AddDocumentsRequest(BaseModel):
+    documents: List[str]
+    metadatas: Optional[List[dict]] = None
+
+
+class SearchRequest(BaseModel):
+    query: str
+    k: int = Field(default=4, ge=1, le=20)
+
+
+class SearchResult(BaseModel):
+    id: int
+    text: str
+    score: float
+    rank: int
+    metadata: dict = {}
+
+
+class SearchResponse(BaseModel):
+    results: List[SearchResult]
+    query: str
+
+
+class RAGChatRequest(BaseModel):
+    query: str
+    model: Optional[str] = None
+    k: int = Field(default=3, ge=1, le=10)
+    temperature: Optional[float] = 0.7
+    max_tokens: Optional[int] = None
+    provider_id: Optional[str] = None
+    user_id: Optional[str] = None
+
+
+class VectorStoreStats(BaseModel):
+    total_vectors: int
+    dimension: int
+    index_type: str
+    metadata_count: int
+
+
+class DeleteDocumentsRequest(BaseModel):
+    document_ids: List[int]
+
+
+class DeleteDocumentsResponse(BaseModel):
+    status: str
+    deleted: int
+    remaining_vectors: int
+`
+        : '';
+    return `"""Pydantic models for the AI Service. Auto-generated by ChimerAI CLI."""
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing import List, Optional, Union
+from enum import Enum
+${chatModels}${embeddingModels}${ragModels}`;
+}
+/**
+ * Generate requirements.txt — only dependencies for installed modules.
+ */
+function generateAiServiceRequirements(modules, tools = []) {
+    // Core dependencies (always)
+    const deps = new Set([
+        'fastapi>=0.104.1',
+        'uvicorn[standard]>=0.24.0',
+        'pydantic>=2.10.0',
+        'pydantic-settings>=2.7.0',
+        'httpx>=0.25.2',
+        'litellm>=1.17.0',
+        'structlog>=23.2.0',
+        'python-dotenv>=1.0.0',
+        'python-multipart>=0.0.6',
+    ]);
+    // Chat module
+    if (modules.includes('chat')) {
+        deps.add('openai>=1.6.1');
+    }
+    // RAG module
+    if (modules.includes('rag')) {
+        deps.add('faiss-cpu>=1.9.0');
+        deps.add('numpy>=1.26.2');
+        deps.add('openai>=1.6.1');
+        deps.add('langchain-text-splitters>=0.3.0');
+        deps.add('pymupdf>=1.24.0');
+        deps.add('python-docx>=1.1.0');
+    }
+    // Guardrails — no additional deps (uses regex from stdlib)
+    // Tools
+    for (const tool of tools) {
+        const info = exports.TOOL_INFO[tool];
+        if (info) {
+            for (const dep of info.dependencies) {
+                deps.add(dep);
+            }
+        }
+    }
+    // Sort and deduplicate
+    const sorted = Array.from(deps).sort((a, b) => {
+        const nameA = a.split('>=')[0].split('[')[0].toLowerCase();
+        const nameB = b.split('>=')[0].split('[')[0].toLowerCase();
+        return nameA.localeCompare(nameB);
+    });
+    return `# ChimerAI AI Service Dependencies — Auto-generated by ChimerAI CLI
+# Modules: ${modules.join(', ') || 'core'}
+# Tools: ${tools.join(', ') || 'none'}
+
+${sorted.join('\n')}
+`;
+}
+/**
+ * Generate Dockerfile for the AI-Service.
+ */
+function generateAiServiceDockerfile() {
+    return `FROM python:3.11-slim
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y \\
+    build-essential \\
+    curl \\
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+RUN mkdir -p /app/models /app/data
+
+EXPOSE 8002
+
+HEALTHCHECK --interval=30s --timeout=10s --start-period=40s --retries=3 \\
+    CMD curl -f http://localhost:8002/health || exit 1
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8002"]
+`;
+}
+/**
+ * Generate README.md for the AI-Service.
+ */
+function generateAiServiceReadme(modules, tools = []) {
+    const moduleList = modules.map((m) => `- **${m}**`).join('\n');
+    const toolList = tools.length > 0
+        ? tools.map((t) => `- ${exports.TOOL_INFO[t]?.displayName || t}`).join('\n')
+        : '- No tools installed';
+    return `# ChimerAI AI Service
+
+Auto-generated by ChimerAI CLI. This is a standalone FastAPI service that provides AI capabilities for your project.
+
+## Installed Modules
+
+${moduleList}
+
+## Installed Tools
+
+${toolList}
+
+## Quick Start
+
+### Option 1: Local (recommended for development)
+
+\`\`\`bash
+cd services/ai
+python -m venv .venv
+
+# Activate virtual environment
+# Windows:
+.venv\\\\Scripts\\\\activate
+# macOS/Linux:
+source .venv/bin/activate
+
+pip install -r requirements.txt
+uvicorn main:app --reload --port 8002
+\`\`\`
+
+### Option 2: Docker
+
+\`\`\`bash
+docker compose up ai-service
+\`\`\`
+
+### Option 3: ChimerAI Dev (starts everything)
+
+\`\`\`bash
+chimerai dev
+\`\`\`
+
+## Endpoints
+
+- Health Check: \`GET /health\`
+${modules.includes('chat') ? '- Chat: `POST /api/chat`\n- Streaming: `POST /api/chat/stream`\n- Models: `GET /api/models`\n- Moderation: `POST /api/moderate`' : ''}
+${modules.includes('rag') ? '- Add Documents: `POST /api/rag/documents`\n- Search: `POST /api/rag/search`\n- RAG Chat: `POST /api/rag/chat`\n- Stats: `GET /api/rag/stats`\n- Embeddings: `POST /api/embeddings`' : ''}
+${modules.includes('guardrails') ? '- PII Detection: `POST /api/guardrails/pii/detect`\n- PII Redaction: `POST /api/guardrails/pii/redact`\n- Toxicity: `POST /api/guardrails/toxicity`\n- Injection Detection: `POST /api/guardrails/injection`' : ''}
+${tools.length > 0 ? '- Tools: `POST /api/tools/*`' : ''}
+
+## Configuration
+
+Environment variables (set in \`.env\` or \`.env.local\`):
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| \`OPENAI_API_KEY\` | — | OpenAI API key (fallback) |
+| \`FRONTEND_URL\` | http://localhost:3000 | Next.js frontend URL |
+| \`INTERNAL_API_TOKEN\` | — | Token for Frontend ↔ AI Service communication |
+
+## Python Version
+
+Requires **Python 3.11+**.
+`;
+}
+/**
+ * Generate the Docker Compose ai-service block to be appended.
+ */
+function generateDockerComposeAiService() {
+    return `
+  ai-service:
+    build:
+      context: .
+      dockerfile: services/ai/Dockerfile
+    container_name: \${COMPOSE_PROJECT_NAME:-chimerai}-ai-service
+    restart: unless-stopped
+    ports:
+      - "\${AI_SERVICE_PORT:-8002}:8002"
+    environment:
+      - FRONTEND_URL=http://app:3000
+      - INTERNAL_API_TOKEN=\${INTERNAL_API_TOKEN}
+      - OPENAI_API_KEY=\${OPENAI_API_KEY}
+      - REDIS_URL=redis://redis:6379
+    volumes:
+      - ai_data:/app/data
+    networks:
+      - chimerai-network
+`;
+}