express-genix 3.0.1 → 4.1.1

package/README.md

@@ -42,6 +42,13 @@ A production-grade CLI tool that generates Express.js applications with best-in-
 - Prometheus metrics (`/metrics` endpoint with prom-client)
 - Audit logging middleware with request tracking and sensitive field redaction
 
+**AI & Agent Integration**
+- MCP Server — exposes your API as tools for AI agents (Claude Desktop, Cursor, Copilot)
+- LangChain / LangGraph AI service with chat, streaming (SSE), prompt chains, and ReAct agent
+- Provider-agnostic: OpenAI, Anthropic, Google Gemini, Ollama (local)
+- AI-powered CLI: `express-genix ai "describe your app"` generates a project from natural language
+- **Coda VS Code extension** — in-editor AI chat for Express Genix projects (auto-prompted on AI/MCP projects)
+
 **Developer Experience**
 - Interactive prompts — pick language, database, features via checkbox
 - Winston or Pino logger (you choose)
@@ -84,7 +91,7 @@ You'll be prompted for:
 1. **Project name**
 2. **Language** — JavaScript or TypeScript
 3. **Database** — MongoDB, PostgreSQL (Sequelize), PostgreSQL (Prisma), or None
-4. **Features** — Auth, Rate Limiting, Swagger, Redis, Docker, CI/CD, WebSocket, Request ID, Email, File Uploads, Soft Deletes, Audit Logging, Prometheus Metrics, API Versioning, Background Jobs, GraphQL
+4. **Features** — Auth, Rate Limiting, Swagger, Redis, Docker, CI/CD, WebSocket, Request ID, Email, File Uploads, Soft Deletes, Audit Logging, Prometheus Metrics, API Versioning, Background Jobs, GraphQL, MCP Server, AI/LLM Service
 5. **Logger** — Winston or Pino
 
 The CLI generates your project, installs dependencies, formats code, and creates an initial git commit.
@@ -111,6 +118,16 @@ express-genix add websocket   # Adds Socket.io setup
 express-genix add prisma      # Adds Prisma schema, client config, migrations
 ```
 
+### Generate from natural language (AI)
+
+Requires `OPENAI_API_KEY` or `ANTHROPIC_API_KEY` in your environment.
+
+```bash
+express-genix ai "a task manager API with auth, real-time updates, and email notifications"
+```
+
+The CLI interprets your description, maps it to features, shows the config for confirmation, then generates the project.
+
 ## Generated Project Structure
 
 ```
@@ -120,6 +137,8 @@ my-express-app/
 │   ├── controllers/     # Route handlers (auth, user, admin, example)
 │   ├── graphql/         # GraphQL type definitions & resolvers (if selected)
 │   ├── jobs/            # BullMQ background workers (if selected)
+│   ├── mcp/             # MCP server for AI agent tools (if selected)
+│   ├── agents/          # LangGraph ReAct agent (if selected)
 │   ├── middleware/      # Auth, RBAC, validation, error handling, uploads, metrics, audit log
 │   ├── models/          # Database models (Mongoose/Sequelize/Prisma)
 │   ├── routes/          # API route definitions with Swagger annotations
@@ -132,6 +151,7 @@ my-express-app/
 ├── migrations/          # Sequelize migrations (if PostgreSQL + Sequelize)
 ├── seeders/             # Sequelize seeders (if PostgreSQL + Sequelize)
 ├── uploads/             # File upload directory (if selected)
+├── mcp.json             # MCP client config for Claude Desktop (if selected)
 ├── .github/workflows/   # CI/CD pipeline (if selected)
 ├── .env                 # Auto-generated environment config
 ├── .env.example         # Template for team sharing
@@ -189,6 +209,14 @@ my-express-app/
 | GET | `/metrics` | Prometheus metrics (prom-client) |
 | GET | `/graphql` | GraphQL Playground (Apollo Server) |
 
+### AI / LLM (LangChain)
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| POST | `/api/ai/chat` | Chat with AI (complete response) |
+| POST | `/api/ai/stream` | Stream AI response (SSE) |
+| POST | `/api/ai/chain` | Run a prompt template chain |
+| POST | `/api/ai/agent` | Run LangGraph ReAct agent with tools |
+
 ## Available Scripts
 
 ```bash
@@ -212,6 +240,7 @@ npm run prisma:studio    # Open Prisma Studio
 express-genix init --skip-install   # Skip npm install (useful for CI)
 express-genix init --skip-cleanup   # Skip auto-formatting (for debugging)
 express-genix add <feature>         # Add feature to existing project
+express-genix ai "<description>"    # Generate project from natural language
 ```
 
 ## Environment Variables
@@ -237,6 +266,14 @@ Generated `.env` includes auto-generated JWT secrets:
 | `EMAIL_FROM` | Default sender address | — |
 | `UPLOAD_MAX_SIZE` | Max file upload size in bytes | `5242880` (5 MB) |
 | `UPLOAD_DIR` | Upload destination directory | `uploads` |
+| `MCP_SERVER_NAME` | MCP server display name | project name |
+| `AI_PROVIDER` | LLM provider (`openai`, `anthropic`, `ollama`) | `openai` |
+| `AI_MODEL` | Model name | `gpt-4o-mini` |
+| `AI_TEMPERATURE` | Sampling temperature | `0.7` |
+| `AI_MAX_TOKENS` | Max response tokens | `2048` |
+| `OPENAI_API_KEY` | OpenAI API key (if using OpenAI) | — |
+| `ANTHROPIC_API_KEY` | Anthropic API key (if using Anthropic) | — |
+| `OLLAMA_BASE_URL` | Ollama server URL (if using Ollama) | `http://localhost:11434` |
 
 ## Docker
 
@@ -246,6 +283,42 @@ docker-compose up --build
 
 The generated `docker-compose.yml` includes services for your app and its dependencies (MongoDB/PostgreSQL, Redis) with health checks, volumes, and a shared network. The `Dockerfile` uses multi-stage builds, runs as a non-root user, and only copies production dependencies.
 
+## Coda VS Code Extension
+
+When you select **AI** or **MCP** features, the CLI prompts you to install the **Coda** VS Code extension — an in-editor AI assistant that talks to your running project's AI endpoints.
+
+### What it does
+
+- **Sidebar chat** — a chat panel in the VS Code activity bar that streams responses from your project's `/ai/chat` and `/ai/stream` endpoints
+- **`@coda` in Copilot Chat** — type `@coda` in the native Copilot Chat to interact with your project's AI agent
+- **Agent mode** — toggle between Chat (streaming) and Agent (LangGraph tool-calling) modes
+- **Auto-detection** — activates automatically when it detects an Express Genix project
+- **Code actions** — copy or insert code blocks from AI responses directly into your editor
+
+### Install manually
+
+```bash
+# Download from GitHub Releases
+curl -sLO https://github.com/LambdaAI001/coda/releases/latest/download/coda-ai-0.1.0.vsix
+
+# Install
+code --install-extension coda-ai-0.1.0.vsix
+```
+
+Or grab it from [github.com/LambdaAI001/coda/releases](https://github.com/LambdaAI001/coda/releases).
+
+### Configuration
+
+In VS Code Settings (search "Coda"):
+
+| Setting | Default | Description |
+|---------|---------|-------------|
+| `coda.serverUrl` | `http://localhost:3000` | Your Express server URL |
+| `coda.apiPrefix` | `/api/v1` | API prefix path |
+| `coda.aiProvider` | `openai` | AI provider (openai, anthropic, gemini, ollama) |
+| `coda.model` | *(server default)* | Model override |
+| `coda.systemPrompt` | *Coding assistant prompt* | Default system prompt |
+
 ## Contributing
 
 Contributions are welcome! Please read our [Contributing Guide](CONTRIBUTING.md) for details.

package/index.js

@@ -14,6 +14,50 @@ const prompt = inquirer.createPromptModule();
 
 const generateSecret = (length = 64) => crypto.randomBytes(length).toString('hex');
 
+const CODA_EXTENSION_ID = 'express-genix.coda-ai';
+const CODA_VSIX_URL = 'https://github.com/LambdaAI001/coda/releases/download/v0.1.0/coda-ai-0.1.0.vsix';
+
+async function promptCodaExtension() {
+  const inquirerPrompt = inquirer.createPromptModule();
+  console.log('');
+  console.log('🤖 Your project includes AI/MCP features.');
+  console.log('   The Coda VS Code extension lets you chat with your AI agent');
+  console.log('   directly from VS Code — no extra setup needed.');
+  console.log('');
+
+  const { installCoda } = await inquirerPrompt([
+    {
+      type: 'confirm',
+      name: 'installCoda',
+      message: 'Install the Coda AI VS Code extension?',
+      default: true,
+    },
+  ]);
+
+  if (!installCoda) return;
+
+  try {
+    // Check if VS Code CLI is available
+    execSync('code --version', { stdio: 'pipe' });
+
+    // Download .vsix from GitHub Releases and install
+    const os = require('os');
+    const tmpFile = path.join(os.tmpdir(), 'coda-ai.vsix');
+    console.log('\n📦 Downloading Coda AI extension...');
+    execSync(`curl -sL -o "${tmpFile}" "${CODA_VSIX_URL}"`, { stdio: 'pipe' });
+    console.log('📦 Installing...');
+    execSync(`code --install-extension "${tmpFile}"`, { stdio: 'pipe' });
+    // Clean up temp file
+    try { fs.unlinkSync(tmpFile); } catch {}
+    console.log('✅ Coda extension installed! Open your project in VS Code to use it.');
+    console.log('   Look for the Coda AI icon in the sidebar, or type @coda in Copilot Chat.');
+  } catch {
+    console.log('\n⚠️  Could not install automatically. Install it manually:');
+    console.log('   1. Download from: https://github.com/LambdaAI001/coda/releases');
+    console.log('   2. Then run: code --install-extension coda-ai-0.1.0.vsix');
+  }
+}
+
 async function main() {
   program
     .name('express-genix')
@@ -83,6 +127,8 @@ async function main() {
             { name: 'API Versioning (/api/v1)', value: 'apiVersioning' },
             { name: 'Background Jobs (BullMQ)', value: 'backgroundJobs' },
             { name: 'GraphQL (Apollo Server)', value: 'graphql' },
+            { name: 'MCP Server (AI Agent Tools)', value: 'mcp' },
+            { name: 'AI / LLM Service (LangChain)', value: 'ai' },
           ],
           when: (ans) => ans.db !== 'none',
         },
@@ -102,6 +148,8 @@ async function main() {
             { name: 'Prometheus Metrics', value: 'metrics' },
             { name: 'API Versioning (/api/v1)', value: 'apiVersioning' },
             { name: 'GraphQL (Apollo Server)', value: 'graphql' },
+            { name: 'MCP Server (AI Agent Tools)', value: 'mcp' },
+            { name: 'AI / LLM Service (LangChain)', value: 'ai' },
           ],
           when: (ans) => ans.db === 'none',
         },
@@ -142,6 +190,8 @@ async function main() {
         hasApiVersioning: features.includes('apiVersioning'),
         hasBackgroundJobs: features.includes('backgroundJobs'),
         hasGraphQL: features.includes('graphql'),
+        hasMCP: features.includes('mcp'),
+        hasAI: features.includes('ai'),
         jwtSecret: generateSecret(),
         jwtRefreshSecret: generateSecret(),
       };
@@ -184,7 +234,7 @@ async function main() {
 To get started:
   cd ${config.projectName}
   npm run dev
-${config.hasSwagger ? `\nAPI Documentation: http://localhost:3000/api-docs` : ''}${config.hasGraphQL ? `\nGraphQL Playground: http://localhost:3000/graphql` : ''}${config.hasMetrics ? `\nPrometheus Metrics: http://localhost:3000/metrics` : ''}
+${config.hasSwagger ? `\nAPI Documentation: http://localhost:3000/api-docs` : ''}${config.hasGraphQL ? `\nGraphQL Playground: http://localhost:3000/graphql` : ''}${config.hasMetrics ? `\nPrometheus Metrics: http://localhost:3000/metrics` : ''}${config.hasMCP ? `\nMCP Server:          npm run mcp:start` : ''}${config.hasAI ? `\nAI Endpoints:        http://localhost:3000/api${config.hasApiVersioning ? '/v1' : ''}/ai/chat` : ''}
 Health Check: http://localhost:3000/health
 
 Available scripts:
@@ -203,6 +253,11 @@ Configuration:
   Features:       ${features.join(', ') || 'base'}
 `);
 
+        // Prompt to install Coda VS Code extension for AI/MCP projects
+        if (config.hasAI || config.hasMCP) {
+          await promptCodaExtension();
+        }
+
       } catch (error) {
         // Rollback: remove partial project directory on failure
         if (fs.existsSync(projectDir)) {
@@ -245,6 +300,110 @@ Configuration:
       }
     });
 
+  program
+    .command('ai <description>')
+    .description('Generate a project from a natural language description (requires OPENAI_API_KEY or ANTHROPIC_API_KEY)')
+    .option('--skip-install', 'Skip npm install')
+    .option('--skip-cleanup', 'Skip post-generation cleanup')
+    .action(async (description, options) => {
+      const { runAiCommand } = require('./lib/ai-cli');
+      const aiConfig = await runAiCommand(description);
+
+      const inquirerPrompt = inquirer.createPromptModule();
+      const { confirmed } = await inquirerPrompt([
+        {
+          type: 'confirm',
+          name: 'confirmed',
+          message: 'Generate project with this configuration?',
+          default: true,
+        },
+      ]);
+
+      if (!confirmed) {
+        console.log('Cancelled.');
+        process.exit(0);
+      }
+
+      const features = aiConfig.features || [];
+      const config = {
+        projectName: aiConfig.projectName,
+        language: aiConfig.language || 'javascript',
+        db: aiConfig.db || 'none',
+        logger: aiConfig.logger || 'winston',
+        hasDatabase: aiConfig.db !== 'none',
+        isNoDatabase: aiConfig.db === 'none',
+        isPrisma: aiConfig.db === 'prisma',
+        isTypescript: aiConfig.language === 'typescript',
+        hasAuth: features.includes('auth') && aiConfig.db !== 'none',
+        hasRateLimit: features.includes('rateLimit'),
+        hasSwagger: features.includes('swagger'),
+        hasDocker: features.includes('docker'),
+        hasCicd: features.includes('cicd'),
+        hasWebsocket: features.includes('websocket'),
+        hasRequestId: features.includes('requestId'),
+        hasRedis: features.includes('redis') && features.includes('auth') && aiConfig.db !== 'none',
+        hasEmail: features.includes('email') && aiConfig.db !== 'none',
+        hasFileUpload: features.includes('fileUpload'),
+        hasSoftDelete: features.includes('softDelete') && aiConfig.db !== 'none',
+        hasAuditLog: features.includes('auditLog'),
+        hasMetrics: features.includes('metrics'),
+        hasApiVersioning: features.includes('apiVersioning'),
+        hasBackgroundJobs: features.includes('backgroundJobs'),
+        hasGraphQL: features.includes('graphql'),
+        hasMCP: features.includes('mcp'),
+        hasAI: features.includes('ai'),
+        jwtSecret: generateSecret(),
+        jwtRefreshSecret: generateSecret(),
+      };
+
+      const projectDir = path.join(process.cwd(), config.projectName);
+
+      if (fs.existsSync(projectDir)) {
+        console.error(`\n❌ Directory "${config.projectName}" already exists!`);
+        process.exit(1);
+      }
+
+      const dbLabel = config.isNoDatabase ? 'no database' : config.db;
+      console.log(`\n🚀 Creating ${config.projectName} (${config.language}, ${dbLabel})...\n`);
+
+      try {
+        await generateProject(config, projectDir, options);
+
+        if (!options.skipCleanup) {
+          await runPostGenerationCleanup(projectDir, config);
+        }
+
+        try {
+          execSync('git init', { cwd: projectDir, stdio: 'pipe' });
+          execSync('git add -A', { cwd: projectDir, stdio: 'pipe' });
+          execSync('git commit -m "Initial commit from express-genix ai"', {
+            cwd: projectDir,
+            stdio: 'pipe',
+            env: { ...process.env, GIT_COMMITTER_NAME: 'express-genix', GIT_COMMITTER_EMAIL: 'cli@express-genix.dev', GIT_AUTHOR_NAME: 'express-genix', GIT_AUTHOR_EMAIL: 'cli@express-genix.dev' },
+          });
+        } catch {
+          // Git not available
+        }
+
+        console.log(`\n✅ Project ${config.projectName} created from AI description!\n`);
+        console.log(`  cd ${config.projectName}`);
+        console.log('  npm run dev\n');
+
+        // Prompt to install Coda VS Code extension for AI/MCP projects
+        if (config.hasAI || config.hasMCP) {
+          await promptCodaExtension();
+        }
+
+      } catch (error) {
+        if (fs.existsSync(projectDir)) {
+          fs.rmSync(projectDir, { recursive: true, force: true });
+          console.error('\n🧹 Rolled back partial project directory.');
+        }
+        console.error(`\n❌ Failed to create project: ${error.message}`);
+        process.exit(1);
+      }
+    });
+
   await program.parseAsync(process.argv);
 }
 

package/lib/ai-cli.js

@@ -0,0 +1,133 @@
+/**
+ * AI CLI handler — interprets natural language project descriptions
+ * and maps them to express-genix configuration flags.
+ *
+ * Requires @langchain/openai or @langchain/anthropic to be installed.
+ * These are NOT bundled with express-genix to keep the CLI lightweight.
+ *
+ * Install with: npm install -g @langchain/core @langchain/openai
+ */
+
+const SYSTEM_PROMPT = `You are an expert Express.js project configurator for the express-genix CLI tool.
+Given a natural language description of a web application, output a JSON configuration object.
+
+Available options:
+- projectName: string (lowercase, hyphens only, no spaces)
+- language: "javascript" | "typescript"
+- db: "mongodb" | "postgresql" | "prisma" | "none"
+- logger: "winston" | "pino"
+- features: array of feature strings from this list:
+  - "auth" (JWT authentication — requires a database)
+  - "rateLimit" (rate limiting)
+  - "swagger" (Swagger/OpenAPI docs)
+  - "redis" (Redis token blacklist — requires auth)
+  - "docker" (Docker & Docker Compose)
+  - "cicd" (GitHub Actions CI/CD)
+  - "websocket" (WebSocket via Socket.io)
+  - "requestId" (request ID / correlation tracking)
+  - "email" (Nodemailer email service — requires database)
+  - "fileUpload" (Multer file uploads)
+  - "softDelete" (soft deletes — requires database + auth)
+  - "auditLog" (audit logging middleware)
+  - "metrics" (Prometheus metrics)
+  - "apiVersioning" (API versioning /api/v1)
+  - "backgroundJobs" (BullMQ background jobs)
+  - "graphql" (GraphQL via Apollo Server)
+  - "mcp" (MCP Server — exposes API as AI-agent tools)
+  - "ai" (LangChain/LangGraph AI service)
+
+Rules:
+- Always include "auth", "rateLimit", "swagger", "requestId" unless explicitly unwanted
+- Include "docker" for production-ready apps
+- Include "ai" if the description mentions AI, chatbot, LLM, or intelligence
+- Include "mcp" if the description mentions AI agents, tools, or MCP
+- Choose "prisma" for modern stacks, "mongodb" for documents, "postgresql" for relational
+- Infer a short kebab-case project name from the description
+- Output ONLY valid JSON. No explanation, no markdown fences.`;
+
+const runAiCommand = async (description) => {
+  // Check for API key
+  const hasOpenAI = !!process.env.OPENAI_API_KEY;
+  const hasAnthropic = !!process.env.ANTHROPIC_API_KEY;
+  const hasGemini = !!process.env.GOOGLE_API_KEY;
+
+  if (!hasOpenAI && !hasAnthropic && !hasGemini) {
+    console.error('❌ The AI command requires an API key.');
+    console.error('   Set one of these environment variables:');
+    console.error('     export OPENAI_API_KEY=sk-...');
+    console.error('     export ANTHROPIC_API_KEY=sk-ant-...');
+    console.error('     export GOOGLE_API_KEY=AI...');
+    process.exit(1);
+  }
+
+  // Try to load LangChain (not bundled — must be installed separately)
+  let ChatModel;
+  try {
+    if (hasGemini) {
+      const { ChatGoogleGenerativeAI } = require('@langchain/google-genai');
+      ChatModel = new ChatGoogleGenerativeAI({
+        model: 'gemini-2.0-flash',
+        maxOutputTokens: 1024,
+        apiKey: process.env.GOOGLE_API_KEY,
+      });
+    } else if (hasAnthropic) {
+      const { ChatAnthropic } = require('@langchain/anthropic');
+      ChatModel = new ChatAnthropic({
+        modelName: 'claude-sonnet-4-20250514',
+        maxTokens: 1024,
+        anthropicApiKey: process.env.ANTHROPIC_API_KEY,
+      });
+    } else {
+      const { ChatOpenAI } = require('@langchain/openai');
+      ChatModel = new ChatOpenAI({
+        modelName: 'gpt-4o-mini',
+        maxTokens: 1024,
+        openAIApiKey: process.env.OPENAI_API_KEY,
+      });
+    }
+  } catch {
+    console.error('❌ LangChain packages not found.');
+    console.error('   Install them globally to use the AI command:');
+    console.error('     npm install -g @langchain/core @langchain/openai @langchain/anthropic @langchain/google-genai');
+    process.exit(1);
+  }
+
+  const { HumanMessage, SystemMessage } = require('@langchain/core/messages');
+
+  console.log('🤖 Analyzing your description...\n');
+
+  const response = await ChatModel.invoke([
+    new SystemMessage(SYSTEM_PROMPT),
+    new HumanMessage(description),
+  ]);
+
+  let config;
+  try {
+    const jsonMatch = response.content.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) throw new Error('No JSON found in response');
+    config = JSON.parse(jsonMatch[0]);
+  } catch {
+    console.error('❌ Could not parse AI response. Try a clearer description.');
+    console.error('   Raw output:', response.content);
+    process.exit(1);
+  }
+
+  // Validate required fields
+  if (!config.projectName || !config.language || !config.db) {
+    console.error('❌ AI response missing required fields. Try again.');
+    process.exit(1);
+  }
+
+  // Display interpreted config
+  console.log('📋 Interpreted configuration:\n');
+  console.log(`   Project:    ${config.projectName}`);
+  console.log(`   Language:   ${config.language}`);
+  console.log(`   Database:   ${config.db}`);
+  console.log(`   Logger:     ${config.logger || 'winston'}`);
+  console.log(`   Features:   ${(config.features || []).join(', ') || 'base'}`);
+  console.log('');
+
+  return config;
+};
+
+module.exports = { runAiCommand };

package/lib/features.js

@@ -240,6 +240,8 @@ const inferConfig = (projectDir, pkg) => {
     hasApiVersioning: false,
     hasBackgroundJobs: !!(pkg.dependencies && pkg.dependencies.bullmq),
     hasGraphQL: !!(pkg.dependencies && pkg.dependencies['@apollo/server']),
+    hasMCP: !!(pkg.dependencies && pkg.dependencies['@modelcontextprotocol/sdk']),
+    hasAI: !!(pkg.dependencies && pkg.dependencies['@langchain/core']),
     logger: pkg.dependencies && pkg.dependencies.pino ? 'pino' : 'winston',
   };
 };

package/lib/generator.js

@@ -61,6 +61,14 @@ const createDirectoryStructure = (projectDir, config) => {
     dirs.push('src/graphql');
   }
 
+  if (config.hasMCP) {
+    dirs.push('src/mcp');
+  }
+
+  if (config.hasAI) {
+    dirs.push('src/agents');
+  }
+
   fs.mkdirSync(projectDir);
   dirs.forEach((dir) => {
     fs.mkdirSync(path.join(projectDir, dir), { recursive: true });
@@ -144,6 +152,10 @@ const generateFiles = async (config, projectDir) => {
     configFiles.push({ template: 'config/queue.js.ejs', output: `src/config/queue.${ext}` });
   }
 
+  if (config.hasAI) {
+    configFiles.push({ template: 'config/ai.js.ejs', output: `src/config/ai.${ext}` });
+  }
+
   // Route files
   const routeFiles = [
     { template: 'routes/index.js.ejs', output: `src/routes/index.${ext}` },
@@ -202,6 +214,18 @@ const generateFiles = async (config, projectDir) => {
     );
   }
 
+  if (config.hasAI) {
+    serviceFiles.push(
+      { template: 'services/aiService.js.ejs', output: `src/services/aiService.${ext}` }
+    );
+    controllerFiles.push(
+      { template: 'controllers/aiController.js.ejs', output: `src/controllers/aiController.${ext}` }
+    );
+    routeFiles.push(
+      { template: 'routes/aiRoutes.js.ejs', output: `src/routes/aiRoutes.${ext}` }
+    );
+  }
+
   if (config.hasFileUpload) {
     routeFiles.push(
       { template: 'routes/uploadRoutes.js.ejs', output: `src/routes/uploadRoutes.${ext}` }
@@ -214,6 +238,35 @@ const generateFiles = async (config, projectDir) => {
     );
   }
 
+  // GraphQL files
+  const graphqlFiles = [];
+
+  if (config.hasGraphQL) {
+    graphqlFiles.push(
+      { template: 'graphql/typeDefs.js.ejs', output: `src/graphql/typeDefs.${ext}` },
+      { template: 'graphql/resolvers.js.ejs', output: `src/graphql/resolvers.${ext}` }
+    );
+  }
+
+  // MCP files
+  const mcpFiles = [];
+
+  if (config.hasMCP) {
+    mcpFiles.push(
+      { template: 'mcp/server.js.ejs', output: `src/mcp/server.${ext}` },
+      { template: 'mcp/mcp-config.json.ejs', output: 'mcp.json' }
+    );
+  }
+
+  // Agent files
+  const agentFiles = [];
+
+  if (config.hasAI) {
+    agentFiles.push(
+      { template: 'agents/graph.js.ejs', output: `src/agents/graph.${ext}` }
+    );
+  }
+
   // Middleware files
   const middlewareFiles = [
     { template: 'middleware/errorHandler.js.ejs', output: `src/middleware/errorHandler.${ext}` },
@@ -303,15 +356,12 @@ const generateFiles = async (config, projectDir) => {
     ...serviceFiles,
     ...utilFiles,
     ...testFiles,
+    ...graphqlFiles,
+    ...mcpFiles,
+    ...agentFiles,
   ];
 
-  // GraphQL files
-  if (config.hasGraphQL) {
-    allFiles.push(
-      { template: 'graphql/typeDefs.js.ejs', output: `src/graphql/typeDefs.${ext}` },
-      { template: 'graphql/resolvers.js.ejs', output: `src/graphql/resolvers.${ext}` }
-    );
-  }
+  // GraphQL files (legacy — now handled above)
 
   // Background job worker
   if (config.hasBackgroundJobs) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "express-genix",
-    "version": "3.0.1",
+    "version": "4.1.1",
     "description": "Production-grade CLI to generate Express apps with JWT, RBAC, GraphQL, TypeScript, Prisma, MongoDB, PostgreSQL, file uploads, email, background jobs, and more",
     "main": "index.js",
     "bin": {

package/templates/agents/graph.js.ejs

@@ -0,0 +1,85 @@
+const { createReactAgent } = require('@langchain/langgraph/prebuilt');
+const { tool } = require('@langchain/core/tools');
+const { HumanMessage } = require('@langchain/core/messages');
+const { z } = require('zod');
+const { getModel } = require('../config/ai');
+
+// --- Built-in Tools ---
+
+const currentTimeTool = tool(
+  async () => new Date().toISOString(),
+  {
+    name: 'current_time',
+    description: 'Get the current date and time in ISO 8601 format',
+    schema: z.object({}),
+  }
+);
+
+const calculatorTool = tool(
+  async ({ expression }) => {
+    // Only allow digits and math operators — no code injection possible
+    const sanitized = expression.replace(/[^0-9+\-*/().%\s]/g, '');
+    if (sanitized !== expression.trim()) {
+      return 'Error: Expression contains invalid characters. Use only numbers and +, -, *, /, (, ), %';
+    }
+    try {
+      const result = new Function(`"use strict"; return (${sanitized})`)();
+      if (!isFinite(result)) return 'Error: Result is not a finite number';
+      return String(result);
+    } catch {
+      return 'Error: Could not evaluate expression';
+    }
+  },
+  {
+    name: 'calculator',
+    description: 'Evaluate a mathematical expression using standard operators: +, -, *, /, %',
+    schema: z.object({
+      expression: z.string().describe('Math expression, e.g. "2 + 3 * 4"'),
+    }),
+  }
+);
+
+/**
+ * Create a LangGraph ReAct agent with tool-calling capabilities.
+ *
+ * @param {Object} options
+ * @param {Array}  options.tools - Additional @langchain/core tools to register
+ * @param {string} options.systemPrompt - System instruction for the agent
+ * @param {string} options.provider - AI provider (openai, anthropic, ollama)
+ * @param {string} options.model - Model name override
+ */
+const createAgent = (options = {}) => {
+  const tools = [
+    currentTimeTool,
+    calculatorTool,
+    ...(options.tools || []),
+  ];
+
+  const model = getModel(options);
+
+  return createReactAgent({
+    llm: model,
+    tools,
+    messageModifier: options.systemPrompt || 'You are a helpful assistant. Use the provided tools when needed to answer questions accurately.',
+  });
+};
+
+/**
+ * Run the agent with a single message and return the final response.
+ */
+const runAgent = async (message, options = {}) => {
+  const agent = createAgent(options);
+
+  const result = await agent.invoke({
+    messages: [new HumanMessage(message)],
+  });
+
+  const lastMessage = result.messages[result.messages.length - 1];
+
+  return {
+    content: lastMessage.content,
+    steps: result.messages.length,
+  };
+};
+
+module.exports = { createAgent, runAgent, currentTimeTool, calculatorTool };

package/templates/config/ai.js.ejs

@@ -0,0 +1,54 @@
+const { ChatOpenAI } = require('@langchain/openai');
+const { ChatAnthropic } = require('@langchain/anthropic');
+const { ChatOllama } = require('@langchain/ollama');
+const { ChatGoogleGenerativeAI } = require('@langchain/google-genai');
+
+/**
+ * Create a LangChain chat model based on the configured provider.
+ * Supports OpenAI, Anthropic, Google Gemini, and Ollama (local).
+ */
+const getModel = (options = {}) => {
+  const provider = (options.provider || process.env.AI_PROVIDER || 'openai').toLowerCase();
+  const temperature = options.temperature ?? parseFloat(process.env.AI_TEMPERATURE || '0.7');
+  const maxTokens = options.maxTokens ?? parseInt(process.env.AI_MAX_TOKENS || '2048', 10);
+
+  switch (provider) {
+    case 'openai':
+      return new ChatOpenAI({
+        modelName: options.model || process.env.AI_MODEL || 'gpt-4o-mini',
+        temperature,
+        maxTokens,
+        openAIApiKey: process.env.OPENAI_API_KEY,
+      });
+
+    case 'anthropic':
+      return new ChatAnthropic({
+        modelName: options.model || process.env.AI_MODEL || 'claude-sonnet-4-20250514',
+        temperature,
+        maxTokens,
+        anthropicApiKey: process.env.ANTHROPIC_API_KEY,
+      });
+
+    case 'gemini':
+      return new ChatGoogleGenerativeAI({
+        model: options.model || process.env.AI_MODEL || 'gemini-2.0-flash',
+        temperature,
+        maxOutputTokens: maxTokens,
+        apiKey: process.env.GOOGLE_API_KEY,
+      });
+
+    case 'ollama':
+      return new ChatOllama({
+        model: options.model || process.env.AI_MODEL || 'llama3',
+        temperature,
+        baseUrl: process.env.OLLAMA_BASE_URL || 'http://localhost:11434',
+      });
+
+    default:
+      throw new Error(
+        `Unsupported AI provider: "${provider}". Supported: openai, anthropic, gemini, ollama`
+      );
+  }
+};
+
+module.exports = { getModel };

package/templates/controllers/aiController.js.ejs

@@ -0,0 +1,102 @@
+const aiService = require('../services/aiService');
+const { runAgent } = require('../agents/graph');
+const { success, error } = require('../utils/response');
+
+/**
+ * POST /ai/chat — Send a message, get a complete AI response.
+ */
+const chatHandler = async (req, res, next) => {
+  try {
+    const { message, systemPrompt, history, provider, model, temperature, maxTokens } = req.body;
+
+    if (!message) {
+      return res.status(400).json(error('Message is required'));
+    }
+
+    const result = await aiService.chat(message, {
+      systemPrompt,
+      history,
+      provider,
+      model,
+      temperature,
+      maxTokens,
+    });
+
+    res.json(success(result));
+  } catch (err) {
+    next(err);
+  }
+};
+
+/**
+ * POST /ai/stream — Stream an AI response via Server-Sent Events.
+ */
+const streamHandler = async (req, res, next) => {
+  try {
+    const { message, systemPrompt, history, provider, model, temperature, maxTokens } = req.body;
+
+    if (!message) {
+      return res.status(400).json(error('Message is required'));
+    }
+
+    res.setHeader('Content-Type', 'text/event-stream');
+    res.setHeader('Cache-Control', 'no-cache');
+    res.setHeader('Connection', 'keep-alive');
+
+    const generator = aiService.stream(message, {
+      systemPrompt,
+      history,
+      provider,
+      model,
+      temperature,
+      maxTokens,
+    });
+
+    for await (const chunk of generator) {
+      res.write(`data: ${JSON.stringify({ content: chunk })}\n\n`);
+    }
+
+    res.write('data: [DONE]\n\n');
+    res.end();
+  } catch (err) {
+    next(err);
+  }
+};
+
+/**
+ * POST /ai/chain — Run a prompt template chain with variables.
+ */
+const chainHandler = async (req, res, next) => {
+  try {
+    const { template, variables, provider, model } = req.body;
+
+    if (!template) {
+      return res.status(400).json(error('Template is required'));
+    }
+
+    const result = await aiService.chain(template, variables || {}, { provider, model });
+    res.json(success({ content: result }));
+  } catch (err) {
+    next(err);
+  }
+};
+
+/**
+ * POST /ai/agent — Run the LangGraph ReAct agent.
+ */
+const agentHandler = async (req, res, next) => {
+  try {
+    const { message, systemPrompt, provider, model } = req.body;
+
+    if (!message) {
+      return res.status(400).json(error('Message is required'));
+    }
+
+    const result = await runAgent(message, { systemPrompt, provider, model });
+    res.json(success(result));
+  } catch (err) {
+    next(err);
+  }
+};
+
+module.exports = { chatHandler, streamHandler, chainHandler, agentHandler };

package/templates/core/env.ejs

@@ -28,6 +28,19 @@ FRONTEND_URL=http://localhost:3000
 # File Uploads
 UPLOAD_DIR=uploads
 UPLOAD_MAX_SIZE=5242880
+<% } %><% if (hasMCP) { %>
+# MCP Server
+MCP_SERVER_NAME=<%= projectName %>
+<% } %><% if (hasAI) { %>
+# AI Service (LangChain)
+AI_PROVIDER=openai
+AI_MODEL=gpt-4o-mini
+AI_TEMPERATURE=0.7
+AI_MAX_TOKENS=2048
+OPENAI_API_KEY=
+# ANTHROPIC_API_KEY=
+# GOOGLE_API_KEY=
+# OLLAMA_BASE_URL=http://localhost:11434
 <% } %><% if (db === 'mongodb') { %>
 # Database
 MONGO_URI=mongodb://localhost:27017/<%= projectName %>

package/templates/core/env.example.ejs

@@ -28,6 +28,19 @@ FRONTEND_URL=http://localhost:3000
 # File Uploads
 UPLOAD_DIR=uploads
 UPLOAD_MAX_SIZE=5242880
+<% } %><% if (hasMCP) { %>
+# MCP Server
+MCP_SERVER_NAME=<%= projectName %>
+<% } %><% if (hasAI) { %>
+# AI Service (LangChain)
+AI_PROVIDER=openai
+AI_MODEL=gpt-4o-mini
+AI_TEMPERATURE=0.7
+AI_MAX_TOKENS=2048
+OPENAI_API_KEY=
+# ANTHROPIC_API_KEY=
+# GOOGLE_API_KEY=
+# OLLAMA_BASE_URL=http://localhost:11434
 <% } %><% if (db === 'mongodb') { %>
 # Database
 MONGO_URI=mongodb://localhost:27017/<%= projectName %>

package/templates/core/package.json.ejs

@@ -18,7 +18,8 @@
     "db:migrate": "npx sequelize-cli db:migrate",
     "db:migrate:undo": "npx sequelize-cli db:migrate:undo",
     "db:seed": "npx sequelize-cli db:seed:all",
-    "db:create": "npx sequelize-cli db:create"<% } %>
+    "db:create": "npx sequelize-cli db:create"<% } %><% if (hasMCP) { %>,
+    "mcp:start": "node src/mcp/server.js"<% } %>
   },
   "dependencies": {
     "express": "^4.21.0",
@@ -31,7 +32,7 @@
     "swagger-ui-express": "^5.0.1"<% } %><% if (hasAuth) { %>,
     "jsonwebtoken": "^9.0.2",
     "bcryptjs": "^2.4.3",
-    "validator": "^13.12.0",
+    "validator": "^13.12.0"<% } %><% if (hasAuth || hasMCP || hasAI) { %>,
     "zod": "^3.23.0"<% } %><% if (db === 'mongodb') { %>,
     "mongoose": "^8.8.0"<% } %><% if (db === 'postgresql') { %>,
     "pg": "^8.13.0",
@@ -46,7 +47,14 @@
     "@apollo/server": "^4.11.0",
     "graphql": "^16.9.0",
     "graphql-tag": "^2.12.6"<% } %><% if (hasBackgroundJobs) { %>,
-    "bullmq": "^5.12.0"<% } %><% if (logger === 'winston') { %>,
+    "bullmq": "^5.12.0"<% } %><% if (hasMCP) { %>,
+    "@modelcontextprotocol/sdk": "^1.12.0"<% } %><% if (hasAI) { %>,
+    "@langchain/core": "^0.3.0",
+    "@langchain/openai": "^0.5.0",
+    "@langchain/anthropic": "^0.3.0",
+    "@langchain/google-genai": "^0.2.0",
+    "@langchain/ollama": "^0.1.0",
+    "@langchain/langgraph": "^0.2.0"<% } %><% if (logger === 'winston') { %>,
     "winston": "^3.15.0"<% } %><% if (logger === 'pino') { %>,
     "pino": "^9.5.0",
     "pino-pretty": "^13.0.0"<% } %>

package/templates/mcp/mcp-config.json.ejs

@@ -0,0 +1,9 @@
+{
+  "mcpServers": {
+    "<%= projectName %>": {
+      "command": "node",
+      "args": ["src/mcp/server.js"],
+      "cwd": "/path/to/<%= projectName %>"
+    }
+  }
+}

package/templates/mcp/server.js.ejs

@@ -0,0 +1,151 @@
+require('dotenv').config();
+
+const { McpServer } = require('@modelcontextprotocol/sdk/server/mcp.js');
+const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
+const { z } = require('zod');
+<% if (hasDatabase) { %>const db = require('../config/database');
+<% } %><% if (hasAuth) { %>const userService = require('../services/userService');
+<% } %><% if (!hasAuth && !isNoDatabase) { %>const exampleService = require('../services/exampleService');
+<% } %><% if (hasEmail) { %>const emailService = require('../services/emailService');
+<% } %>
+
+const server = new McpServer({
+  name: process.env.MCP_SERVER_NAME || '<%= projectName %>',
+  version: '1.0.0',
+});
+
+<% if (hasAuth) { %>
+// --- User Management Tools ---
+
+server.tool(
+  'list_users',
+  'List all registered users with pagination',
+  {
+    page: z.number().optional().describe('Page number (default: 1)'),
+    limit: z.number().optional().describe('Items per page (default: 20)'),
+  },
+  async ({ page = 1, limit = 20 }) => {
+    const result = await userService.findAll({ page, limit });
+    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+  }
+);
+
+server.tool(
+  'get_user',
+  'Get a user by their ID',
+  {
+    userId: z.string().describe('The user ID to look up'),
+  },
+  async ({ userId }) => {
+    const user = await userService.findById(userId);
+    if (!user) {
+      return { content: [{ type: 'text', text: 'User not found' }], isError: true };
+    }
+    const { password, ...safeUser } = user.toJSON ? user.toJSON() : user;
+    return { content: [{ type: 'text', text: JSON.stringify(safeUser, null, 2) }] };
+  }
+);
+
+server.tool(
+  'register_user',
+  'Register a new user account',
+  {
+    username: z.string().describe('Username for the new account'),
+    email: z.string().email().describe('Email address'),
+    password: z.string().min(8).describe('Password (min 8 characters)'),
+  },
+  async ({ username, email, password }) => {
+    const bcrypt = require('bcryptjs');
+    const existing = await userService.findByEmail(email);
+    if (existing) {
+      return { content: [{ type: 'text', text: 'A user with this email already exists' }], isError: true };
+    }
+    const hashedPassword = await bcrypt.hash(password, 12);
+    const user = await userService.create({ username, email, password: hashedPassword });
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({ id: user.id, username: user.username, email: user.email, role: user.role || 'user' }, null, 2),
+      }],
+    };
+  }
+);
+<% } %>
+<% if (!hasAuth) { %>
+// --- Example CRUD Tools ---
+
+server.tool(
+  'list_examples',
+  'List all example items with pagination',
+  {
+    page: z.number().optional().describe('Page number (default: 1)'),
+    limit: z.number().optional().describe('Items per page (default: 20)'),
+  },
+  async ({ page = 1, limit = 20 }) => {
+    const result = await exampleService.getAll({ page, limit });
+    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+  }
+);
+
+server.tool(
+  'create_example',
+  'Create a new example item',
+  {
+    title: z.string().describe('Item title'),
+    description: z.string().optional().describe('Item description'),
+  },
+  async ({ title, description }) => {
+    const item = await exampleService.create({ title, description });
+    return { content: [{ type: 'text', text: JSON.stringify(item, null, 2) }] };
+  }
+);
+<% } %>
+<% if (hasEmail) { %>
+// --- Email Tools ---
+
+server.tool(
+  'send_email',
+  'Send an email to a recipient',
+  {
+    to: z.string().email().describe('Recipient email address'),
+    subject: z.string().describe('Email subject line'),
+    html: z.string().describe('Email body in HTML format'),
+  },
+  async ({ to, subject, html }) => {
+    const info = await emailService.sendMail({ to, subject, html });
+    return { content: [{ type: 'text', text: `Email sent successfully (ID: ${info.messageId})` }] };
+  }
+);
+<% } %>
+
+// --- Health Check Tool ---
+
+server.tool(
+  'health_check',
+  'Check the application health and status',
+  {},
+  async () => {
+    const health = {
+      status: 'OK',
+      uptime: `${Math.floor(process.uptime())}s`,
+      memoryUsage: `${Math.round(process.memoryUsage().rss / 1024 / 1024)} MB`,
+      timestamp: new Date().toISOString(),
+    };
+    return { content: [{ type: 'text', text: JSON.stringify(health, null, 2) }] };
+  }
+);
+
+// --- Start MCP Server ---
+
+const main = async () => {
+<% if (hasDatabase) { %>  await db.connect();
+<% } %>
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error(`MCP server "${process.env.MCP_SERVER_NAME || '<%= projectName %>'}" running on stdio`);
+};
+
+main().catch((err) => {
+  console.error('Failed to start MCP server:', err);
+  process.exit(1);
+});

package/templates/middleware/auditLog.js.ejs

@@ -1,4 +1,4 @@
-const logger = require('../utils/logger');
+const { logger } = require('../utils/logger');
 
 /**
  * Audit Logging Middleware
@@ -47,10 +47,12 @@ const auditLog = (action) => (req, res, next) => {
       }
     }
 
+    const message = `${auditEntry.method} ${auditEntry.path} ${auditEntry.statusCode} ${auditEntry.duration}`;
+
     if (res.statusCode >= 400) {
-      logger.warn(auditEntry);
+      logger.warn(message, auditEntry);
     } else {
-      logger.info(auditEntry);
+      logger.info(message, auditEntry);
     }
 
     originalEnd.apply(res, args);

package/templates/routes/aiRoutes.js.ejs

@@ -0,0 +1,126 @@
+const express = require('express');
+const { chatHandler, streamHandler, chainHandler, agentHandler } = require('../controllers/aiController');
+
+const router = express.Router();
+
+/**
+ * @swagger
+ * /api<% if (hasApiVersioning) { %>/v1<% } %>/ai/chat:
+ *   post:
+ *     summary: Send a chat message to the AI
+ *     tags: [AI]
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             required: [message]
+ *             properties:
+ *               message:
+ *                 type: string
+ *                 example: "What is Node.js?"
+ *               systemPrompt:
+ *                 type: string
+ *                 example: "You are a helpful coding assistant."
+ *               history:
+ *                 type: array
+ *                 items:
+ *                   type: object
+ *                   properties:
+ *                     role:
+ *                       type: string
+ *                       enum: [user, assistant]
+ *                     content:
+ *                       type: string
+ *               provider:
+ *                 type: string
+ *                 enum: [openai, anthropic, gemini, ollama]
+ *               model:
+ *                 type: string
+ *     responses:
+ *       200:
+ *         description: AI response
+ */
+router.post('/chat', chatHandler);
+
+/**
+ * @swagger
+ * /api<% if (hasApiVersioning) { %>/v1<% } %>/ai/stream:
+ *   post:
+ *     summary: Stream an AI response via Server-Sent Events
+ *     tags: [AI]
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             required: [message]
+ *             properties:
+ *               message:
+ *                 type: string
+ *     responses:
+ *       200:
+ *         description: SSE stream of AI response chunks
+ */
+router.post('/stream', streamHandler);
+
+/**
+ * @swagger
+ * /api<% if (hasApiVersioning) { %>/v1<% } %>/ai/chain:
+ *   post:
+ *     summary: Run a prompt template chain with variable substitution
+ *     tags: [AI]
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             required: [template]
+ *             properties:
+ *               template:
+ *                 type: string
+ *                 example: "Summarize the following text: {text}"
+ *               variables:
+ *                 type: object
+ *                 example: { "text": "Node.js is a JavaScript runtime..." }
+ *               provider:
+ *                 type: string
+ *                 enum: [openai, anthropic, gemini, ollama]
+ *     responses:
+ *       200:
+ *         description: Chain result
+ */
+router.post('/chain', chainHandler);
+
+/**
+ * @swagger
+ * /api<% if (hasApiVersioning) { %>/v1<% } %>/ai/agent:
+ *   post:
+ *     summary: Run the LangGraph ReAct agent with tool calling
+ *     tags: [AI]
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             required: [message]
+ *             properties:
+ *               message:
+ *                 type: string
+ *                 example: "What time is it right now?"
+ *               systemPrompt:
+ *                 type: string
+ *               provider:
+ *                 type: string
+ *                 enum: [openai, anthropic, gemini, ollama]
+ *     responses:
+ *       200:
+ *         description: Agent response with tool-use steps
+ */
+router.post('/agent', agentHandler);
+
+module.exports = router;

package/templates/routes/index.js.ejs

@@ -5,6 +5,7 @@ const adminRoutes = require('./adminRoutes');
 <% } else { %>const exampleRoutes = require('./exampleRoutes');
 <% } %><% if (hasFileUpload) { %>const uploadRoutes = require('./uploadRoutes');
 <% } %><% if (hasBackgroundJobs) { %>const jobRoutes = require('./jobRoutes');
+<% } %><% if (hasAI) { %>const aiRoutes = require('./aiRoutes');
 <% } %>
 
 const router = express.Router();
@@ -15,6 +16,7 @@ router.use('/admin', adminRoutes);
 <% } else { %>router.use('/examples', exampleRoutes);
 <% } %><% if (hasFileUpload) { %>router.use('/uploads', uploadRoutes);
 <% } %><% if (hasBackgroundJobs) { %>router.use('/jobs', jobRoutes);
+<% } %><% if (hasAI) { %>router.use('/ai', aiRoutes);
 <% } %>
 
 /**

package/templates/services/aiService.js.ejs

@@ -0,0 +1,80 @@
+const { getModel } = require('../config/ai');
+const { HumanMessage, SystemMessage, AIMessage } = require('@langchain/core/messages');
+const { StringOutputParser } = require('@langchain/core/output_parsers');
+const { ChatPromptTemplate } = require('@langchain/core/prompts');
+const logger = require('../utils/logger');
+
+const DEFAULT_SYSTEM_PROMPT = 'You are a helpful AI assistant.';
+
+/**
+ * Send a chat message and get a complete response.
+ */
+const chat = async (message, options = {}) => {
+  const model = getModel(options);
+  const messages = [
+    new SystemMessage(options.systemPrompt || DEFAULT_SYSTEM_PROMPT),
+  ];
+
+  if (Array.isArray(options.history)) {
+    for (const msg of options.history) {
+      if (msg.role === 'user') messages.push(new HumanMessage(msg.content));
+      else if (msg.role === 'assistant') messages.push(new AIMessage(msg.content));
+    }
+  }
+
+  messages.push(new HumanMessage(message));
+
+  const response = await model.invoke(messages);
+
+  logger.info('AI chat completed', {
+    provider: options.provider || process.env.AI_PROVIDER || 'openai',
+  });
+
+  return {
+    content: response.content,
+    model: response.response_metadata?.model || 'unknown',
+    usage: response.usage_metadata || null,
+  };
+};
+
+/**
+ * Stream a chat response. Returns an async generator yielding text chunks.
+ */
+const stream = async function* (message, options = {}) {
+  const model = getModel(options);
+  const messages = [
+    new SystemMessage(options.systemPrompt || DEFAULT_SYSTEM_PROMPT),
+  ];
+
+  if (Array.isArray(options.history)) {
+    for (const msg of options.history) {
+      if (msg.role === 'user') messages.push(new HumanMessage(msg.content));
+      else if (msg.role === 'assistant') messages.push(new AIMessage(msg.content));
+    }
+  }
+
+  messages.push(new HumanMessage(message));
+
+  const streamResponse = await model.stream(messages);
+
+  for await (const chunk of streamResponse) {
+    if (chunk.content) {
+      yield chunk.content;
+    }
+  }
+};
+
+/**
+ * Run a prompt template chain with variable substitution.
+ */
+const chain = async (template, variables = {}, options = {}) => {
+  const model = getModel(options);
+  const prompt = ChatPromptTemplate.fromTemplate(template);
+  const outputParser = new StringOutputParser();
+  const pipeline = prompt.pipe(model).pipe(outputParser);
+
+  const result = await pipeline.invoke(variables);
+  return result;
+};
+
+module.exports = { chat, stream, chain };