architectgbt-mcp 0.1.0

package/README.md

@@ -0,0 +1,133 @@
+# ArchitectGBT MCP Server
+
+AI model recommendation engine for Cursor, Claude Desktop, and Windsurf.
+
+Get instant AI model recommendations without leaving your IDE.
+
+## Features
+
+- 🎯 **Smart Recommendations** - Get the best AI model for your use case
+- 📝 **Code Templates** - Production-ready integration code
+- 📊 **Model Database** - Compare 50+ AI models with pricing
+
+## Installation
+
+### For Cursor
+
+Add to your `~/.cursor/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "architectgbt": {
+      "command": "npx",
+      "args": ["@architectgbt/mcp"]
+    }
+  }
+}
+```
+
+### For Claude Desktop
+
+Add to your Claude Desktop config (`%APPDATA%\Claude\claude_desktop_config.json` on Windows):
+
+```json
+{
+  "mcpServers": {
+    "architectgbt": {
+      "command": "npx",
+      "args": ["@architectgbt/mcp"]
+    }
+  }
+}
+```
+
+### For Windsurf
+
+Add to your MCP configuration:
+
+```json
+{
+  "mcpServers": {
+    "architectgbt": {
+      "command": "npx",
+      "args": ["@architectgbt/mcp"]
+    }
+  }
+}
+```
+
+## Available Tools
+
+### `get_ai_recommendation`
+
+Get personalized AI model recommendations based on your project description.
+
+**Example prompts:**
+- "What AI model should I use for a customer support chatbot?"
+- "Recommend a model for code generation on a budget"
+- "Best model for document analysis with 100K context?"
+
+### `get_code_template`
+
+Get production-ready integration code for any AI model.
+
+**Example prompts:**
+- "Give me a TypeScript template for Claude"
+- "Python code for OpenAI GPT-4"
+- "Gemini integration in TypeScript"
+
+### `list_models`
+
+List available AI models with pricing information.
+
+**Example prompts:**
+- "List all Anthropic models"
+- "Show me the cheapest models"
+- "What OpenAI models are available?"
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Run in development mode
+npm run dev
+
+# Build for production
+npm run build
+
+# Start production server
+npm start
+```
+
+## Local Testing
+
+To test locally before publishing, update your MCP config to point to the built file:
+
+```json
+{
+  "mcpServers": {
+    "architectgbt": {
+      "command": "node",
+      "args": ["C:/Users/pravi/workspacenew/architectgbt-mcp/dist/index.js"]
+    }
+  }
+}
+```
+
+## Environment Variables
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `ARCHITECTGBT_API_URL` | API base URL | `https://architectgbt.com` |
+
+## License
+
+MIT
+
+## Links
+
+- [ArchitectGBT Website](https://architectgbt.com)
+- [MCP Documentation](https://modelcontextprotocol.io)

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,51 @@
+#!/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/dist/templates/index.d.ts

@@ -0,0 +1,6 @@
+export declare const templates: Record<string, Record<string, {
+    install: string;
+    envVars: string[];
+    code: string;
+    usage: string;
+}>>;

package/dist/templates/index.js

@@ -0,0 +1,116 @@
+export const templates = {
+    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/dist/tools/get-recommendation.d.ts

@@ -0,0 +1,37 @@
+export declare const getRecommendationTool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            prompt: {
+                type: string;
+                description: string;
+            };
+            budget: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            priority: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handleGetRecommendation(args: unknown): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+    isError?: undefined;
+} | {
+    content: {
+        type: string;
+        text: string;
+    }[];
+    isError: boolean;
+}>;

package/dist/tools/get-recommendation.js

@@ -0,0 +1,94 @@
+import { z } from "zod";
+const API_BASE = process.env.ARCHITECTGBT_API_URL || "https://architectgbt.com";
+export const getRecommendationTool = {
+    name: "get_ai_recommendation",
+    description: "Analyze a project description and recommend the best AI model with pricing, reasoning, and alternatives. Use this when someone asks which AI model to use for their project.",
+    inputSchema: {
+        type: "object",
+        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) {
+    const input = InputSchema.parse(args);
+    try {
+        const response = await fetch(`${API_BASE}/api/recommend`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                prompt: input.prompt,
+                budget: input.budget,
+                priority: input.priority,
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`API error: ${response.status}`);
+        }
+        const data = await response.json();
+        // Format the response nicely
+        const result = formatRecommendation(data);
+        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) {
+    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, i) => {
+            result += `${i + 1}. **${alt.name}** - ${alt.reason || alt.description || ""}\n`;
+        });
+    }
+    result += `\n---\n*Powered by [ArchitectGBT](https://architectgbt.com)*`;
+    return result;
+}

package/dist/tools/get-template.d.ts

@@ -0,0 +1,25 @@
+export declare const getTemplateTool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            model: {
+                type: string;
+                description: string;
+            };
+            language: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handleGetTemplate(args: unknown): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;

package/dist/tools/get-template.js

@@ -0,0 +1,78 @@
+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",
+        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) {
+    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/dist/tools/list-models.d.ts

@@ -0,0 +1,32 @@
+export declare const listModelsTool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            provider: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            limit: {
+                type: string;
+                description: string;
+            };
+        };
+        required: never[];
+    };
+};
+export declare function handleListModels(args: unknown): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+    isError?: undefined;
+} | {
+    content: {
+        type: string;
+        text: string;
+    }[];
+    isError: boolean;
+}>;

package/dist/tools/list-models.js

@@ -0,0 +1,61 @@
+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",
+        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) {
+    const input = InputSchema.parse(args);
+    try {
+        const response = await fetch(`${API_BASE}/api/models`);
+        if (!response.ok) {
+            throw new Error(`API error: ${response.status}`);
+        }
+        let models = await response.json();
+        // Filter by provider if specified
+        if (input.provider && input.provider !== "all") {
+            models = models.filter((m) => m.provider?.toLowerCase() === input.provider?.toLowerCase());
+        }
+        // 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`;
+        models.forEach((m) => {
+            result += `| ${m.name} | ${m.provider} | $${m.input_price || "?"} | $${m.output_price || "?"} |\n`;
+        });
+        result += `\n*Showing ${models.length} models. Use \`get_ai_recommendation\` for personalized suggestions.*`;
+        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/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "architectgbt-mcp",
+  "version": "0.1.0",
+  "description": "MCP server for AI model recommendations from ArchitectGBT",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "architectgbt-mcp": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts"
+  },
+  "keywords": ["mcp", "ai", "model", "recommendation", "architectgbt", "cursor", "claude"],
+  "author": "ArchitectGBT",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "zod": "^3.22.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.0.0"
+  },
+  "files": ["dist"],
+  "engines": {
+    "node": ">=18"
+  }
+}