k-god-mcp

Chieji/k-god-mcp

3.3

If you are the rightful owner of k-god-mcp and would like to certify it and/or have it hosted online, please leave a comment on the right or send an email to dayong@mcphub.com.

K-God MCP Server is a multi-API integration server designed for seamless connectivity with Claude Desktop, VSCode, and AI assistants, offering access to over 20 APIs through a single platform.

Tools
5
Resources
0
Prompts
0

🔥 K-God MCP Server

CI Docker Release License: MIT

Multi-API Integration Server for Claude Desktop, VSCode, and AI Assistants

Access 20+ APIs through a single MCP server with both .env file configuration and a beautiful web UI for managing your API keys.

🚀 Features

20 API Integrations

Free/Cheap LLMs (6 APIs)
  • ✅ Cohere - FREE embeddings, chat, reranking
  • ✅ Groq - FREE ultra-fast inference (Llama, Mixtral, Gemma)
  • ✅ DeepInfra - Cheapest inference rates
  • ✅ SambaNova - FREE tier available
  • ✅ Google Gemini - Generous FREE tier
  • ✅ OpenRouter - Access to 100+ models (some FREE)
Premium LLMs (2 APIs)
  • ✅ OpenAI - GPT-4, embeddings, DALL-E
  • ✅ Anthropic Claude - Claude models
Search & Data (3 APIs)
  • ✅ Tavily - AI-optimized search
  • ✅ Serper.dev - Google search API
  • ✅ OpenWeather - Weather data
Infrastructure (4 APIs)
  • ✅ Supabase - Database, auth, storage
  • ✅ GitHub - Repo operations, issues
  • ✅ Google Cloud - Storage, BigQuery, etc.
  • ✅ Ngrok - Tunnel management
Specialized AI (2 APIs)
  • ✅ Replicate - ML model hosting
  • ✅ Jina AI - Embeddings & reranking
Automation (3 APIs)
  • ✅ Steel.dev - Browser automation
  • ✅ Notion - Knowledge base
  • ✅ Context7 - API context management

📦 Installation

Prerequisites

  • Python 3.11+
  • pip or Docker

Option 1: Direct Installation

# Clone or navigate to project
cd k-god-mcp

# Install dependencies
pip install -r requirements.txt

# Copy environment template
cp .env.example .env

# Edit .env with your API keys (or use the Config UI)

Option 2: Docker Installation

# Build and run with Docker Compose
docker-compose up -d

# Or build manually
docker build -t k-god-mcp .
docker run -v $(pwd)/.env:/app/.env k-god-mcp

🔧 Configuration

Option A: Config UI (Recommended)

  1. Start the Config UI:
python config_ui.py

  1. Open browser to http://localhost:3000

  2. Add your API keys through the beautiful web interface

  3. Test each API connection with one click

  4. Keys are automatically saved to .env

Option B: Manual .env File

Edit .env file directly:

# Free LLMs
COHERE_API_KEY=your_key_here
GROQ_API_KEY=your_key_here
GOOGLE_API_KEY=your_key_here

# Premium LLMs
OPENAI_API_KEY=your_key_here
ANTHROPIC_API_KEY=your_key_here

# Search
TAVILY_API_KEY=your_key_here
SERPER_API_KEY=your_key_here

# Infrastructure
GITHUB_TOKEN=your_token_here
SUPABASE_URL=your_url_here
SUPABASE_KEY=your_key_here

# ... etc

🔌 Connect to Claude Desktop

1. Edit Claude Desktop Config

macOS:

code ~/Library/Application\ Support/Claude/claude_desktop_config.json

Windows:

code %APPDATA%\Claude\claude_desktop_config.json

Linux:

code ~/.config/Claude/claude_desktop_config.json

2. Add MCP Server

{
  "mcpServers": {
    "k-god": {
      "command": "python",
      "args": ["/absolute/path/to/k-god-mcp/server.py"],
      "env": {}
    }
  }
}

Or with virtual environment:

{
  "mcpServers": {
    "k-god": {
      "command": "/path/to/venv/bin/python",
      "args": ["/path/to/k-god-mcp/server.py"]
    }
  }
}

3. Restart Claude Desktop

Quit and reopen Claude Desktop. The K-God MCP server will now be available!

🔌 Connect to VSCode (Cascade/Cline)

1. Install MCP Extension

Install the MCP extension in VSCode (if available) or use Cascade/Cline settings.

2. Add to Settings

Open VSCode settings and add:

{
  "mcp.servers": {
    "k-god": {
      "command": "python",
      "args": ["/absolute/path/to/k-god-mcp/server.py"]
    }
  }
}

🎯 Usage Examples

In Claude Desktop:

"Use groq_chat to answer: What is quantum computing?"

"Search the web with tavily_search for latest AI news"

"Generate an embedding with cohere_embed for this text: [your text]"

"Check weather_current for New York"

"Create a GitHub issue with github_create_issue in my repo"

"Query my Supabase database with supabase_query"

List Available APIs:

"Use list_configured_apis to see what's available"

Test Connections:

"Use test_api_connection to test the groq API"

🛠️ Available Tools

Run python server.py and use list_configured_apis tool to see all available tools based on your configured APIs.

Sample Tools:

LLM Tools
  • openai_chat - Chat with GPT models
  • anthropic_chat - Chat with Claude
  • groq_chat - Ultra-fast chat with Groq
  • cohere_chat - Chat with Cohere
  • gemini_generate - Generate with Gemini
Search Tools
  • tavily_search - AI search
  • serper_search - Google search
  • weather_current - Current weather
  • weather_forecast - Weather forecast
Database Tools
  • supabase_query - Query Supabase
  • supabase_insert - Insert to Supabase
  • supabase_update - Update Supabase
GitHub Tools
  • github_repo_info - Get repo info
  • github_create_issue - Create issue
  • github_search_repos - Search repos
And 40+ more tools...

🐳 Docker Deployment

Run MCP Server:

docker-compose up mcp-server -d

Run Config UI:

docker-compose up config-ui -d

Run Both:

docker-compose up -d

View Logs:

docker-compose logs -f mcp-server

🔒 Security Notes

  • ✅ API keys stored in .env (gitignored)
  • ✅ Never commit .env to git
  • ✅ Config UI encrypts sensitive data
  • ✅ Use environment variables in production
  • ✅ Rotate keys regularly

🧪 Testing

Test Individual API:

python -c "
from config import get_settings
from tools.ai.groq_tools import groq_tools
import asyncio

async def test():
    result = await groq_tools.test_connection()
    print(result)

asyncio.run(test())
"

Test All Configured APIs:

Use the Config UI at http://localhost:3000 and click "Test" button for each API.

📝 Development

Project Structure:

k-god-mcp/
├── server.py              # Main MCP server
├── config_ui.py           # Web UI for configuration
├── requirements.txt       # Python dependencies
├── .env.example          # Template for API keys
├── config/
│   └── settings.py       # Settings management
├── tools/
│   ├── ai/              # AI/LLM integrations
│   ├── search/          # Search APIs
│   ├── infrastructure/  # Cloud & dev tools
│   ├── specialized/     # Specialized AI
│   └── automation/      # Automation tools
├── Dockerfile
├── docker-compose.yml
└── README.md

Add New API Integration:

  1. Create tool file in appropriate tools/ subdirectory
  2. Implement is_configured, test_connection(), and get_tools() methods
  3. Add to server.py TOOL_REGISTRY
  4. Add environment variable to .env.example
  5. Update Config UI mapping in config_ui.py

🤝 Contributing

Feel free to add more API integrations! Follow the existing pattern:

  1. Create tool class extending BaseAPITool
  2. Implement required methods
  3. Register in server
  4. Update docs

📄 License

MIT License - Use freely!

🆘 Troubleshooting

"API key not configured"

  • Check .env file has the correct key name
  • Verify key is not empty
  • Use Config UI to test connection

"Module not found"

pip install -r requirements.txt

Claude Desktop not detecting server

  • Use absolute paths in config
  • Restart Claude Desktop completely
  • Check Python path is correct

Config UI not loading

# Make sure port 3000 is not in use
lsof -ti:3000 | xargs kill -9

# Then restart
python config_ui.py

🎉 Credits

Built for maximum flexibility and ease of use. Integrates with:

  • Claude Desktop (Anthropic)
  • VSCode MCP extensions
  • Any MCP-compatible client

Happy API integrating! 🔥

For questions or issues, check your API key configuration first, then test individual APIs using the Config UI.