architectgbt-mcp 0.2.0 → 0.2.1

package/CURSOR_SETUP.md

@@ -0,0 +1,135 @@
+# Cursor IDE Setup for ArchitectGBT MCP
+
+## Quick Start
+
+1. **Open Cursor Settings**
+   - Press `Ctrl+Shift+J` (Windows/Linux) or `Cmd+Shift+J` (Mac)
+   - Or go to: Settings → Features → Model Context Protocol
+
+2. **Add MCP Server Configuration**
+
+Create or edit `.cursor/mcp.json` in your project:
+
+```json
+{
+  "mcpServers": {
+    "architectgbt": {
+      "command": "npx",
+      "args": ["-y", "architectgbt-mcp@0.2.0"]
+    }
+  }
+}
+```
+
+3. **Restart Cursor**
+   - Close and reopen Cursor to load the MCP server
+
+## Usage
+
+### Free Tier (No API Key)
+Get 3 AI model recommendations per day without authentication:
+
+```
+Ask Claude: "recommend an AI model for building a chatbot with 100k daily users"
+```
+
+The MCP server will automatically use the anonymous endpoint.
+
+### Pro Tier (Unlimited Access)
+
+1. **Generate API Key**
+   - Sign in at [architectgbt.com](https://architectgbt.com)
+   - Go to Settings → API Keys
+   - Click "Generate New Key"
+   - Copy the key (shown only once!)
+
+2. **Set Environment Variable**
+
+**Windows (PowerShell):**
+```powershell
+$env:ARCHITECTGBT_API_KEY = "agbt_your_key_here"
+```
+
+**macOS/Linux:**
+```bash
+export ARCHITECTGBT_API_KEY=agbt_your_key_here
+```
+
+**Permanent Setup:**
+- Windows: Add to System Environment Variables
+- macOS/Linux: Add to `~/.bashrc` or `~/.zshrc`
+
+3. **Restart Cursor** with environment variable loaded
+
+## Available Tools
+
+### 1. list_models
+Lists all available AI models with pricing
+
+**Example:**
+```
+"Show me all available AI models"
+"What models support vision?"
+```
+
+### 2. get_ai_recommendation
+Get personalized model recommendations based on requirements
+
+**Example:**
+```
+"Recommend a model for:
+- Building a code assistant
+- Budget: $500/month
+- Needs: function calling, code completion"
+```
+
+### 3. get_template
+Get ready-to-use code templates
+
+**Example:**
+```
+"Show me the Next.js SaaS template"
+"Get the FastAPI template"
+```
+
+## Pricing
+
+- **Free**: 3 recommendations/day (no API key needed)
+- **Pro Monthly ($15)**: 200 credits + unlimited MCP
+- **Pro Annual ($150)**: 150 credits/month + unlimited MCP
+
+[View full pricing →](https://architectgbt.com#pricing)
+
+## Troubleshooting
+
+### MCP Server Not Found
+```bash
+# Force install latest version
+npx -y architectgbt-mcp@latest
+```
+
+### Rate Limited (Free Tier)
+```
+Error: Rate limit exceeded. Limit: 3 requests per day.
+```
+- Wait 24 hours, or
+- Upgrade to Pro for unlimited access
+
+### API Key Invalid
+```
+Error: Invalid API key
+```
+- Check key is correct (starts with `agbt_`)
+- Verify environment variable is set
+- Restart Cursor after setting variable
+
+### Connection Failed
+- Check internet connection
+- Verify firewall allows npm/npx
+- Try manual test: `npx -y architectgbt-mcp@0.2.0`
+
+## Support
+
+- 📧 Email: support@architectgbt.com
+- 🐛 Issues: [github.com/3rdbrain/architectgbt-mcp](https://github.com/3rdbrain/architectgbt-mcp/issues)
+- 📚 Docs: [architectgbt.com/docs](https://architectgbt.com)

package/TESTING.md

@@ -0,0 +1,138 @@
+# Testing ArchitectGBT MCP Integration
+
+## Quick Test Guide
+
+### 1. Set Your API Key
+
+**Windows (PowerShell):**
+```powershell
+$env:ARCHITECTGBT_API_KEY = "your_api_key_here"
+```
+
+**macOS/Linux:**
+```bash
+export ARCHITECTGBT_API_KEY=your_api_key_here
+```
+
+### 2. Configure Cursor IDE
+
+Create or edit `.cursor/mcp.json` in your project:
+
+```json
+{
+  "mcpServers": {
+    "architectgbt": {
+      "command": "npx",
+      "args": ["-y", "architectgbt-mcp@0.2.0"]
+    }
+  }
+}
+```
+
+### 3. Restart Cursor
+
+Close and reopen Cursor IDE to load the MCP server with your API key.
+
+### 4. Test Commands
+
+#### Test 1: List Models
+Ask Claude in Cursor:
+```
+Show me all available AI models
+```
+
+Expected: List of models with pricing
+
+#### Test 2: Get Recommendation
+Ask Claude:
+```
+Recommend an AI model for building a chatbot with 100k daily users and $500/month budget
+```
+
+Expected: Top 3 model recommendations with cost breakdown
+
+#### Test 3: Get Template
+Ask Claude:
+```
+Show me the Next.js SaaS template
+```
+
+Expected: Template code and description
+
+### 5. Verify Unlimited Access
+
+With your API key set:
+- ✅ No rate limits (unlimited recommendations)
+- ✅ Usage tracked in your dashboard
+- ✅ `last_used_at` updates in Settings → API Keys
+
+### 6. Test Without API Key
+
+Remove the environment variable:
+```powershell
+Remove-Item Env:\ARCHITECTGBT_API_KEY
+```
+
+Restart Cursor and try again:
+- ✅ First 3 requests work (anonymous tier)
+- ✅ 4th request shows rate limit error
+
+## Troubleshooting
+
+### API Key Not Working
+
+1. **Check environment variable is set:**
+   ```powershell
+   echo $env:ARCHITECTGBT_API_KEY
+   ```
+
+2. **Verify format:**
+   - Must start with `agbt_`
+   - Should be 37+ characters long
+
+3. **Check Cursor loaded it:**
+   - Restart Cursor after setting the variable
+   - Check Cursor's MCP logs
+
+### MCP Server Not Found
+
+```powershell
+# Test MCP server directly
+npx -y architectgbt-mcp@0.2.0
+```
+
+### Still Getting Rate Limited
+
+- Verify API key is in environment variables
+- Check it matches the key in your dashboard
+- Ensure Cursor was restarted after setting the variable
+
+## Production Testing Checklist
+
+- [ ] Anonymous access works (3/day limit)
+- [ ] API key provides unlimited access
+- [ ] Usage count increments in dashboard
+- [ ] last_used_at updates after each request
+- [ ] Rate limit resets after 24 hours
+- [ ] All 3 tools work (list_models, get_ai_recommendation, get_template)
+- [ ] Error messages are user-friendly
+- [ ] MCP works in both Cursor and Claude Desktop
+
+## API Endpoints Being Used
+
+When using MCP with API key:
+- **GET** `https://architectgbt.com/api/models` - List models
+- **POST** `https://architectgbt.com/api/recommend` - Get recommendations
+
+Headers sent:
+```
+Authorization: Bearer agbt_your_key_here
+Content-Type: application/json
+```
+
+## Next Steps
+
+1. Monitor usage in Settings → API Keys
+2. Check MCP usage analytics (coming soon)
+3. Share MCP package with team members
+4. Upgrade to Pro for unlimited access ($15/month)

package/dist/tools/list-models.js

@@ -48,17 +48,29 @@ export async function handleListModels(args) {
         }
         // Limit results
         models = models.slice(0, input.limit);
-        // Format output
-        let result = `## 📊 Available AI Models\n\n`;
-        result += `| Model | Provider | Input $/1M | Output $/1M |\n`;
-        result += `|-------|----------|------------|-------------|\n`;
+        // Group by provider for better readability
+        const groupedModels = {};
         models.forEach((m) => {
-            // Convert per-1K pricing to per-1M for display
-            const inputPer1M = m.input_cost_per_1k ? (m.input_cost_per_1k * 1000).toFixed(2) : "?";
-            const outputPer1M = m.output_cost_per_1k ? (m.output_cost_per_1k * 1000).toFixed(2) : "?";
-            result += `| ${m.name} | ${m.provider} | $${inputPer1M} | $${outputPer1M} |\n`;
+            const provider = m.provider || "Unknown";
+            if (!groupedModels[provider]) {
+                groupedModels[provider] = [];
+            }
+            groupedModels[provider].push(m);
         });
-        result += `\n*Showing ${models.length} models. Use \`get_ai_recommendation\` for personalized suggestions.*`;
+        // Format output with grouping
+        let result = `Available AI Models (${models.length} total)\n`;
+        result += `${"=".repeat(70)}\n\n`;
+        Object.entries(groupedModels).forEach(([provider, providerModels]) => {
+            result += `${provider}:\n`;
+            providerModels.forEach((m) => {
+                const inputPer1M = m.input_cost_per_1k ? (m.input_cost_per_1k * 1000).toFixed(2) : "?";
+                const outputPer1M = m.output_cost_per_1k ? (m.output_cost_per_1k * 1000).toFixed(2) : "?";
+                result += `  • ${m.name.padEnd(30)} $${inputPer1M.padStart(6)} / $${outputPer1M.padStart(6)} (in/out per 1M tokens)\n`;
+            });
+            result += `\n`;
+        });
+        result += `${"=".repeat(70)}\n`;
+        result += `💡 Tip: Use get_ai_recommendation for personalized model suggestions based on your needs.`;
         return {
             content: [{ type: "text", text: result }],
         };

package/package.json

@@ -1,31 +1,44 @@
 {
   "name": "architectgbt-mcp",
-  "version": "0.2.0",
-  "description": "MCP server for AI model recommendations from ArchitectGBT",
+  "version": "0.2.1",
+  "description": "Model Context Protocol server for ArchitectGBT - AI architecture recommendations",
   "type": "module",
-  "main": "dist/index.js",
   "bin": {
     "architectgbt-mcp": "./dist/index.js"
   },
+  "main": "./dist/index.js",
   "scripts": {
-    "build": "tsc",
-    "start": "node dist/index.js",
-    "dev": "tsx src/index.ts"
+    "build": "tsc && node -e \"require('fs').chmodSync('./dist/index.js', '755')\"",
+    "prepare": "npm run build",
+    "dev": "tsx src/index.ts",
+    "test": "echo 'No tests yet'"
   },
-  "keywords": ["mcp", "ai", "model", "recommendation", "architectgbt", "cursor", "claude"],
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "ai",
+    "architecture",
+    "recommendations",
+    "openai",
+    "anthropic",
+    "claude"
+  ],
   "author": "ArchitectGBT",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yourusername/architectgbt-mcp.git"
+  },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
-    "zod": "^3.22.0"
+    "zod": "^3.23.8"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
-    "tsx": "^4.0.0",
-    "typescript": "^5.0.0"
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.0"
   },
-  "files": ["dist"],
   "engines": {
-    "node": ">=18"
+    "node": ">=18.0.0"
   }
-}
+}

package/src/index.ts

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+
+import { getRecommendationTool, handleGetRecommendation } from "./tools/get-recommendation.js";
+import { getTemplateTool, handleGetTemplate } from "./tools/get-template.js";
+import { listModelsTool, handleListModels } from "./tools/list-models.js";
+
+const server = new Server(
+  {
+    name: "architectgbt-mcp",
+    version: "0.1.0",
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+// List available tools
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: [getRecommendationTool, getTemplateTool, listModelsTool],
+  };
+});
+
+// Handle tool calls
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  try {
+    switch (name) {
+      case "get_ai_recommendation":
+        return await handleGetRecommendation(args);
+      case "get_code_template":
+        return await handleGetTemplate(args);
+      case "list_models":
+        return await handleListModels(args);
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return {
+      content: [{ type: "text", text: `Error: ${message}` }],
+      isError: true,
+    };
+  }
+});
+
+// Start the server
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("ArchitectGBT MCP server running on stdio");
+}
+
+main().catch(console.error);

package/src/templates/index.ts

@@ -0,0 +1,123 @@
+export const templates: Record<string, Record<string, {
+  install: string;
+  envVars: string[];
+  code: string;
+  usage: string;
+}>> = {
+  anthropic: {
+    typescript: {
+      install: "npm install @anthropic-ai/sdk",
+      envVars: ["ANTHROPIC_API_KEY=your-api-key"],
+      code: `import Anthropic from "@anthropic-ai/sdk";
+
+const client = new Anthropic({
+  apiKey: process.env.ANTHROPIC_API_KEY,
+});
+
+export async function chat(message: string): Promise<string> {
+  const response = await client.messages.create({
+    model: "claude-sonnet-4-20250514",
+    max_tokens: 1024,
+    messages: [{ role: "user", content: message }],
+  });
+
+  const textBlock = response.content[0];
+  if (textBlock.type === "text") {
+    return textBlock.text;
+  }
+  throw new Error("Unexpected response type");
+}`,
+      usage: `const answer = await chat("What is the capital of France?");
+console.log(answer);`,
+    },
+    python: {
+      install: "pip install anthropic",
+      envVars: ["ANTHROPIC_API_KEY=your-api-key"],
+      code: `import anthropic
+
+client = anthropic.Anthropic()
+
+def chat(message: str) -> str:
+    response = client.messages.create(
+        model="claude-sonnet-4-20250514",
+        max_tokens=1024,
+        messages=[{"role": "user", "content": message}]
+    )
+    return response.content[0].text`,
+      usage: `answer = chat("What is the capital of France?")
+print(answer)`,
+    },
+  },
+
+  openai: {
+    typescript: {
+      install: "npm install openai",
+      envVars: ["OPENAI_API_KEY=your-api-key"],
+      code: `import OpenAI from "openai";
+
+const client = new OpenAI({
+  apiKey: process.env.OPENAI_API_KEY,
+});
+
+export async function chat(message: string): Promise<string> {
+  const response = await client.chat.completions.create({
+    model: "gpt-4o",
+    messages: [{ role: "user", content: message }],
+  });
+
+  return response.choices[0].message.content || "";
+}`,
+      usage: `const answer = await chat("What is the capital of France?");
+console.log(answer);`,
+    },
+    python: {
+      install: "pip install openai",
+      envVars: ["OPENAI_API_KEY=your-api-key"],
+      code: `from openai import OpenAI
+
+client = OpenAI()
+
+def chat(message: str) -> str:
+    response = client.chat.completions.create(
+        model="gpt-4o",
+        messages=[{"role": "user", "content": message}]
+    )
+    return response.choices[0].message.content`,
+      usage: `answer = chat("What is the capital of France?")
+print(answer)`,
+    },
+  },
+
+  google: {
+    typescript: {
+      install: "npm install @google/generative-ai",
+      envVars: ["GOOGLE_API_KEY=your-api-key"],
+      code: `import { GoogleGenerativeAI } from "@google/generative-ai";
+
+const genAI = new GoogleGenerativeAI(process.env.GOOGLE_API_KEY!);
+
+export async function chat(message: string): Promise<string> {
+  const model = genAI.getGenerativeModel({ model: "gemini-2.0-flash" });
+  const result = await model.generateContent(message);
+  return result.response.text();
+}`,
+      usage: `const answer = await chat("What is the capital of France?");
+console.log(answer);`,
+    },
+    python: {
+      install: "pip install google-generativeai",
+      envVars: ["GOOGLE_API_KEY=your-api-key"],
+      code: `import google.generativeai as genai
+import os
+
+genai.configure(api_key=os.environ["GOOGLE_API_KEY"])
+
+def chat(message: str) -> str:
+    model = genai.GenerativeModel("gemini-2.0-flash")
+    response = model.generate_content(message)
+    return response.text`,
+      usage: `answer = chat("What is the capital of France?")
+print(answer)`,
+    },
+  },
+};

package/src/tools/get-recommendation.ts

@@ -0,0 +1,161 @@
+import { z } from "zod";
+
+const API_BASE = process.env.ARCHITECTGBT_API_URL || "https://architectgbt.com";
+const API_KEY = process.env.ARCHITECTGBT_API_KEY;
+
+export const getRecommendationTool = {
+  name: "get_ai_recommendation",
+  description:
+    "Analyze a project description and recommend the best AI model with pricing, reasoning, and alternatives. Free tier: 3 recommendations/day. Add ARCHITECTGBT_API_KEY for unlimited access.",
+  inputSchema: {
+    type: "object" as const,
+    properties: {
+      prompt: {
+        type: "string",
+        description:
+          "Description of what you want to build (e.g., 'customer support chatbot for e-commerce')",
+      },
+      budget: {
+        type: "string",
+        enum: ["low", "medium", "high", "unlimited"],
+        description: "Budget constraint for API costs",
+      },
+      priority: {
+        type: "string",
+        enum: ["cost", "speed", "quality", "balanced"],
+        description: "What matters most for this project",
+      },
+    },
+    required: ["prompt"],
+  },
+};
+
+const InputSchema = z.object({
+  prompt: z.string(),
+  budget: z.enum(["low", "medium", "high", "unlimited"]).optional(),
+  priority: z.enum(["cost", "speed", "quality", "balanced"]).optional(),
+});
+
+export async function handleGetRecommendation(args: unknown) {
+  const input = InputSchema.parse(args);
+
+  try {
+    // Determine which endpoint to use
+    const endpoint = API_KEY ? `${API_BASE}/api/recommend` : `${API_BASE}/api/recommend/public`;
+    
+    // Build headers
+    const headers: HeadersInit = {
+      "Content-Type": "application/json",
+    };
+    
+    // Add API key if available
+    if (API_KEY) {
+      headers["Authorization"] = `Bearer ${API_KEY}`;
+    }
+
+    const response = await fetch(endpoint, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        prompt: input.prompt,
+        budget: input.budget,
+        priority: input.priority,
+      }),
+    });
+
+    if (!response.ok) {
+      // Handle rate limiting for free tier
+      if (response.status === 429) {
+        const data = await response.json();
+        const resetHeader = response.headers.get('X-RateLimit-Reset');
+        const resetTime = resetHeader ? new Date(resetHeader).toLocaleString() : 'tomorrow';
+        
+        return {
+          content: [
+            {
+              type: "text",
+              text: `🚫 **Daily Limit Reached**\n\n${data.error?.message || 'You\'ve used all 3 free recommendations today.'}\n\nResets at: ${resetTime}\n\n**Get unlimited access:**\n1. Visit https://architectgbt.com\n2. Sign up for free (10 recommendations/month)\n3. Generate an API key from Settings\n4. Add to your MCP config:\n\`\`\`json\n{\n  "mcpServers": {\n    "architectgbt": {\n      "command": "npx",\n      "args": ["-y", "architectgbt-mcp"],\n      "env": {\n        "ARCHITECTGBT_API_KEY": "your_api_key_here"\n      }\n    }\n  }\n}\n\`\`\`\n\n💡 Pro tip: Upgrade to Pro ($15/mo) for unlimited recommendations!`,
+            },
+          ],
+        };
+      }
+      
+      // Handle authentication requirement
+      if (response.status === 401 || response.status === 405) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `❌ **API Key Invalid or Expired**\n\nYour API key is not valid. To fix this:\n\n1. Visit https://architectgbt.com/settings\n2. Generate a new API key\n3. Update your MCP config\n\n**Without an API key:**\nYou can still use the free tier (3 recommendations/day). Remove the ARCHITECTGBT_API_KEY from your config.`,
+            },
+          ],
+        };
+      }
+      throw new Error(`API error: ${response.status}`);
+    }
+
+    const data = await response.json();
+
+    // Show rate limit info if present
+    const remaining = response.headers.get('X-RateLimit-Remaining');
+    const limit = response.headers.get('X-RateLimit-Limit');
+    
+    // Format the response nicely
+    let result = formatRecommendation(data);
+    
+    // Add rate limit footer for free tier
+    if (remaining !== null && limit !== null && !API_KEY) {
+      result += `\n\n---\n📊 **Free Tier:** ${remaining}/${limit} recommendations remaining today\n💎 Get unlimited access at https://architectgbt.com`;
+    }
+
+    return {
+      content: [{ type: "text", text: result }],
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Failed to get recommendation: ${message}. Please try again.`,
+        },
+      ],
+      isError: true,
+    };
+  }
+}
+
+function formatRecommendation(data: any): string {
+  const { recommendation, reasoning, alternatives, model } = data;
+
+  let result = `## 🎯 AI Model Recommendation\n\n`;
+
+  if (model) {
+    result += `### Recommended: ${model.name}\n`;
+    result += `- **Provider:** ${model.provider}\n`;
+    result += `- **Model ID:** ${model.model_id || "N/A"}\n`;
+
+    if (model.input_price || model.output_price) {
+      result += `- **Pricing:** $${model.input_price}/1M input, $${model.output_price}/1M output\n`;
+    }
+
+    if (model.context_window) {
+      result += `- **Context Window:** ${model.context_window.toLocaleString()} tokens\n`;
+    }
+  }
+
+  if (reasoning) {
+    result += `\n### Why This Model?\n${reasoning}\n`;
+  }
+
+  if (alternatives && alternatives.length > 0) {
+    result += `\n### Alternatives\n`;
+    alternatives.forEach((alt: any, i: number) => {
+      result += `${i + 1}. **${alt.name}** - ${alt.reason || alt.description || ""}\n`;
+    });
+  }
+
+  result += `\n---\n*Powered by [ArchitectGBT](https://architectgbt.com)*`;
+
+  return result;
+}

package/src/tools/get-template.ts

@@ -0,0 +1,87 @@
+import { z } from "zod";
+import { templates } from "../templates/index.js";
+
+export const getTemplateTool = {
+  name: "get_code_template",
+  description:
+    "Get a production-ready code template for integrating a specific AI model. Returns working code with setup instructions.",
+  inputSchema: {
+    type: "object" as const,
+    properties: {
+      model: {
+        type: "string",
+        description:
+          "The AI model name (e.g., 'Claude', 'GPT-4', 'Gemini')",
+      },
+      language: {
+        type: "string",
+        enum: ["typescript", "python"],
+        description: "Programming language for the template",
+      },
+    },
+    required: ["model"],
+  },
+};
+
+const InputSchema = z.object({
+  model: z.string(),
+  language: z.enum(["typescript", "python"]).default("typescript"),
+});
+
+export async function handleGetTemplate(args: unknown) {
+  const input = InputSchema.parse(args);
+
+  const modelKey = input.model.toLowerCase();
+  const lang = input.language;
+
+  // Find matching template
+  let template = null;
+
+  if (modelKey.includes("claude") || modelKey.includes("anthropic")) {
+    template = templates.anthropic[lang];
+  } else if (modelKey.includes("gpt") || modelKey.includes("openai")) {
+    template = templates.openai[lang];
+  } else if (modelKey.includes("gemini") || modelKey.includes("google")) {
+    template = templates.google[lang];
+  }
+
+  if (!template) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `No template found for "${input.model}" in ${lang}. Available: Claude/Anthropic, GPT/OpenAI, Gemini/Google.`,
+        },
+      ],
+    };
+  }
+
+  const result = `## 📝 Code Template: ${input.model} (${lang})
+
+### Installation
+\`\`\`bash
+${template.install}
+\`\`\`
+
+### Environment Variables
+\`\`\`
+${template.envVars.join("\n")}
+\`\`\`
+
+### Code
+\`\`\`${lang}
+${template.code}
+\`\`\`
+
+### Usage Example
+\`\`\`${lang}
+${template.usage}
+\`\`\`
+
+---
+*Powered by [ArchitectGBT](https://architectgbt.com)*`;
+
+  return {
+    content: [{ type: "text", text: result }],
+  };
+}

package/src/tools/list-models.ts

@@ -0,0 +1,104 @@
+import { z } from "zod";
+
+const API_BASE = process.env.ARCHITECTGBT_API_URL || "https://architectgbt.com";
+
+export const listModelsTool = {
+  name: "list_models",
+  description:
+    "List available AI models with optional filtering by provider or capability.",
+  inputSchema: {
+    type: "object" as const,
+    properties: {
+      provider: {
+        type: "string",
+        enum: ["OpenAI", "Anthropic", "Google", "Meta", "Mistral", "all"],
+        description: "Filter by provider",
+      },
+      limit: {
+        type: "number",
+        description: "Maximum number of models to return (default: 10)",
+      },
+    },
+    required: [],
+  },
+};
+
+const InputSchema = z.object({
+  provider: z
+    .enum(["OpenAI", "Anthropic", "Google", "Meta", "Mistral", "all"])
+    .optional(),
+  limit: z.number().default(10),
+});
+
+export async function handleListModels(args: unknown) {
+  const input = InputSchema.parse(args);
+
+  try {
+    const response = await fetch(`${API_BASE}/api/models`);
+
+    if (!response.ok) {
+      throw new Error(`API error: ${response.status}`);
+    }
+
+    const responseData = await response.json();
+    
+    // Handle the API response structure: { success: true, data: [...] }
+    let models = responseData.success && Array.isArray(responseData.data) 
+      ? responseData.data 
+      : Array.isArray(responseData) 
+      ? responseData 
+      : [];
+
+    if (!Array.isArray(models)) {
+      throw new Error(`Expected array but got ${typeof models}. API might have changed.`);
+    }
+
+    // Filter by provider if specified
+    if (input.provider && input.provider !== "all") {
+      models = models.filter(
+        (m: any) =>
+          m.provider?.toLowerCase() === input.provider?.toLowerCase()
+      );
+    }
+
+    // Limit results
+    models = models.slice(0, input.limit);
+
+    // Group by provider for better readability
+    const groupedModels: Record<string, any[]> = {};
+    models.forEach((m: any) => {
+      const provider = m.provider || "Unknown";
+      if (!groupedModels[provider]) {
+        groupedModels[provider] = [];
+      }
+      groupedModels[provider].push(m);
+    });
+
+    // Format output with grouping
+    let result = `Available AI Models (${models.length} total)\n`;
+    result += `${"=".repeat(70)}\n\n`;
+
+    Object.entries(groupedModels).forEach(([provider, providerModels]) => {
+      result += `${provider}:\n`;
+      providerModels.forEach((m: any) => {
+        const inputPer1M = m.input_cost_per_1k ? (m.input_cost_per_1k * 1000).toFixed(2) : "?";
+        const outputPer1M = m.output_cost_per_1k ? (m.output_cost_per_1k * 1000).toFixed(2) : "?";
+        result += `  • ${m.name.padEnd(30)} $${inputPer1M.padStart(6)} / $${outputPer1M.padStart(6)} (in/out per 1M tokens)\n`;
+      });
+      result += `\n`;
+    });
+
+    result += `${"=".repeat(70)}\n`;
+    result += `💡 Tip: Use get_ai_recommendation for personalized model suggestions based on your needs.`;
+
+    return {
+      content: [{ type: "text", text: result }],
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return {
+      content: [{ type: "text", text: `Failed to list models: ${message}` }],
+      isError: true,
+    };
+  }
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}