express-genix 3.0.0 → 4.1.0

package/README.md

@@ -3,6 +3,7 @@
 A production-grade CLI tool that generates Express.js applications with best-in-class defaults. Scaffold a complete REST API in seconds — with TypeScript, authentication, Prisma/Mongoose/Sequelize, Docker, CI/CD, and more.
 
 [![npm version](https://img.shields.io/npm/v/express-genix.svg)](https://www.npmjs.com/package/express-genix)
+[![npm downloads](https://img.shields.io/npm/dm/express-genix.svg)](https://www.npmjs.com/package/express-genix)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Node.js](https://img.shields.io/badge/node-%3E%3D18-brightgreen.svg)](https://nodejs.org)
 
@@ -41,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)
@@ -83,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.
@@ -110,24 +118,40 @@ 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
 
 ```
 my-express-app/
 ├── src/
-│   ├── config/          # Database, Swagger, WebSocket configuration
-│   ├── controllers/     # Route handlers
-│   ├── middleware/       # Auth, validation, error handling, request ID
-│   ├── models/          # Database models (Mongoose/Sequelize)
+│   ├── config/          # Database, Swagger, WebSocket, queue configuration
+│   ├── 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
-│   ├── services/        # Business logic layer
+│   ├── services/        # Business logic layer (auth, user, email)
 │   ├── utils/           # Logger, errors, response helpers, validators
 │   ├── app.js|ts        # Express app setup
-│   └── server.js|ts     # Server + clustering + WebSocket
+│   └── server.js|ts     # Server + clustering + WebSocket + workers
 ├── tests/               # Jest + Supertest suites
 ├── prisma/              # Prisma schema (if selected)
 ├── 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
@@ -138,6 +162,8 @@ my-express-app/
 
 ## API Endpoints (with database + auth)
 
+> When API versioning is enabled, all `/api/*` routes become `/api/v1/*`.
+
 ### Authentication
 | Method | Endpoint | Description |
 |--------|----------|-------------|
@@ -153,12 +179,43 @@ my-express-app/
 |--------|----------|-------------|
 | GET | `/api/users/profile` | Get current user |
 | PUT | `/api/users/profile` | Update profile |
-| DELETE | `/api/users/profile` | Delete account |
+| DELETE | `/api/users/profile` | Delete account (soft delete if enabled) |
+
+### Admin (RBAC — admin role required)
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| GET | `/api/admin/users` | List all users (paginated) |
+| GET | `/api/admin/users/:id` | Get user by ID |
+| PUT | `/api/admin/users/:id/role` | Update user role |
+| DELETE | `/api/admin/users/:id` | Delete user |
+| POST | `/api/admin/users/:id/restore` | Restore soft-deleted user |
+
+### File Uploads
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| POST | `/api/uploads/single` | Upload a single file |
+| POST | `/api/uploads/multiple` | Upload multiple files (max 10) |
+
+### Background Jobs (BullMQ)
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| POST | `/api/jobs` | Dispatch a background job |
+| GET | `/api/jobs/:id` | Get job status |
 
-### Health
+### Observability & Health
 | Method | Endpoint | Description |
 |--------|----------|-------------|
-| GET | `/health` | Health check with uptime, DB status, Redis status, memory usage |
+| GET | `/health` | Health check (uptime, DB, Redis, memory) |
+| 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
 
@@ -183,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
@@ -197,10 +255,25 @@ Generated `.env` includes auto-generated JWT secrets:
 | `JWT_SECRET` | Access token secret (auto-generated) | — |
 | `JWT_REFRESH_SECRET` | Refresh token secret (auto-generated) | — |
 | `MONGO_URI` / `DATABASE_URL` | Database connection string | — |
-| `REDIS_URL` | Redis URL (when Redis blacklist enabled) | `redis://localhost:6379` |
+| `REDIS_URL` | Redis URL (token blacklist, caching, BullMQ) | `redis://localhost:6379` |
 | `RATE_LIMIT_WINDOW_MS` | Rate limit window (ms) | `900000` |
 | `RATE_LIMIT_MAX` | Max requests per window | `100` |
 | `LOG_LEVEL` | Logging level | `info` |
+| `SMTP_HOST` | SMTP server host (email service) | — |
+| `SMTP_PORT` | SMTP server port | `587` |
+| `SMTP_USER` | SMTP username | — |
+| `SMTP_PASS` | SMTP password | — |
+| `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
 
@@ -208,6 +281,44 @@ Generated `.env` includes auto-generated JWT secrets:
 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/latest/download/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.0",
+    "version": "4.1.0",
     "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": {