Which integrations are available for this server?

Automatically discovers and generates GraphQL queries for any GraphQL API through introspection, with support for pagination, filters, sorting, and table-formatted query generation

How do I use MCP GraphQL Query Generator?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@MCP GraphQL Query Generator list all available GraphQL queries for my e-commerce API" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

🚀 MCP GraphQL Query Generator

License: MIT TypeScript Bun VS Code GitHub Copilot

A smart Model Context Protocol (MCP) server that automatically discovers and generates GraphQL queries for any API. Works with VS Code + GitHub Copilot, CLI, and REST API to make exploring and using GraphQL APIs effortless.

Perfect for VS Code integration with GitHub Copilot! 🤖

Quick Start • Features • VS Code Setup • API Reference • Examples

What is MCP?

The Model Context Protocol (MCP) is a new protocol that lets tools, APIs, and models talk to each other in a structured way. Instead of manually copying data into your IDE or chat window, MCP servers can: - Provide real-time API access directly inside VS Code or AI tools. - Enable natural language queries ("show me all products with pagination"). - Act as connectors between AI assistants (like Copilot) and external systems. This project is an MCP server for GraphQL APIs: - It introspects any GraphQL schema. - Generates queries automatically. - Exposes them through CLI, REST, and VS Code integration. In short: you don’t need to handcraft GraphQL queries anymore — just ask, and they’re generated for you.

What is this?

This tool automatically introspects any GraphQL API and generates intelligent, production-ready queries with:

Auto-discovery of all available queries and types in your GraphQL API
Smart field selecion, including nested types
Table-formatted queries with pagination, filtering, and sorting
Natural language integration with GitHub Copilot
Zero configuration - just point it to your GraphQL endpoint
Multi-auth support (Bearer, API Key, Keycloak, etc.)
Multiple interfaces (CLI, REST API, MCP Server, Web UI)

Features

For Developers

Instant GraphQL exploration - No need to read documentation
Smart query generation - Automatically includes relevant fields
Production-ready queries - With proper pagination and error handling
Type-safe - Full TypeScript support

For AI Integration

GitHub Copilot integration - Ask questions in natural language
VS Code extension ready - Works globally across all projects
Context-aware - Understands your API structure
Intelligent suggestions - Based on your schema

For Teams

Consistent query patterns - Standardized across projects
Documentation generator - Auto-generates API insights
Multi-environment - Dev, staging, prod configurations
Docker ready - Easy deployment and scaling

Quick Start

Option 1: Global VS Code Installation (Recommended)

Transform VS Code into a GraphQL powerhouse in 2 minutes:

# 1. Install Bun runtime (faster than Node.js) powershell -c "irm bun.sh/install.ps1 | iex" # 2. Clone and install globally git clone https://github.com/marias1lva/mcp-graphql-generator.git cd mcp-graphql-generator .\install-global.ps1 # 3. Add to VS Code settings.json: { "mcp.servers": { "graphql-query-generator": { "name": "GraphQL Query Generator", "url": "http://localhost:3001", "enabled": true } } } # 4. Configure your API notepad %APPDATA%\MCPGraphQLServer\.env # Add: GRAPHQL_API_URL=https://your-api.example.com/graphql

That's it! Now ask GitHub Copilot: "List available GraphQL queries"

Option 2: Local Development

# Clone and setup git clone https://github.com/marias1lva/mcp-graphql-generator.git cd mcp-graphql-generator bun install # Configure API cp .env.example .env # Edit .env with your GraphQL API URL # Start MCP server bun mcp-server.ts # Or use CLI directly bun src/cli.ts list bun src/cli.ts generate listUsers

VS Code Integration

Once installed, use natural language with GitHub Copilot:

👤 "List all available GraphQL queries" 🤖 Found these queries: • listUsers - Get all users with pagination • listProducts - Browse products catalog • listOrders - View order history 👤 "Generate a query to get users with their profiles" 🤖 query ListUsers($first: Int, $after: String) { listUsers(first: $first, after: $after) { edges { node { id name email profile { firstName lastName avatar } } } pageInfo { hasNextPage endCursor } } } 👤 "What fields are available in the Product type?" 🤖 Product type fields: • id (ID!) - Unique identifier • name (String!) - Product name • price (Float!) - Product price • description (String) - Product description • category (Category) - Product category

Usage Options

1. CLI Interface

# Discover available queries bun src/cli.ts list # Generate a specific query bun src/cli.ts generate listUsers # Generate with options bun src/cli.ts generate listProducts --depth 3 --pagination # Interactive mode bun src/cli.ts interactive

2. REST API

### Get all available queries GET http://localhost:3001/mcp/queries ### Generate a specific query POST http://localhost:3001/mcp/generate-query Content-Type: application/json { "queryName": "listUsers", "options": { "includePagination": true, "maxDepth": 2, "selectedFields": ["id", "name", "email"] } } ### Analyze a type GET http://localhost:3001/mcp/analyze/User

3. Programmatic Usage

import { GenericQueryGenerator } from './src/generators/genericQueryGenerator'; const generator = new GenericQueryGenerator(); // Get available queries const queries = await generator.getAvailableQueries(); // Generate a table query const query = await generator.generateTableQuery('listUsers', { includePagination: true, maxDepth: 2 }); // Generate custom query const customQuery = await generator.generateCustomQuery('listUsers', ['id', 'name', 'email'], { includePagination: true } );

Configuration

Environment Variables

# Required: Your GraphQL API endpoint GRAPHQL_API_URL=https://your-api.example.com/graphql # Optional: Authentication API_TOKEN=your_bearer_token API_KEY=your_api_key # Optional: Keycloak authentication KEYCLOAK_CLIENT_ID=your_client_id KEYCLOAK_CLIENT_SECRET=your_client_secret KEYCLOAK_URL=https://your-keycloak.example.com/auth KEYCLOAK_REALM=your-realm # Optional: Server configuration MCP_PORT=3001 MAX_DEPTH=3

Per-Project Configuration

Create .vscode/settings.json in your project:

{ "mcpGraphQL.projectSettings": { "apiUrl": "https://project-specific-api.com/graphql", "authToken": "${env:PROJECT_API_TOKEN}", "defaultDepth": 2, "enablePagination": true } }

Examples

Example Output - List Users Query

query ListUsers($first: Int, $after: String, $orderBy: UserOrderByInput) { listUsers(first: $first, after: $after, orderBy: $orderBy) { edges { node { id name email createdAt profile { firstName lastName avatar } } } pageInfo { hasNextPage hasPreviousPage startCursor endCursor } totalCount } }

Example Output - Products with Categories

query ListProducts($first: Int, $after: String, $filters: ProductFiltersInput) { listProducts(first: $first, after: $after, filters: $filters) { edges { node { id name price description category { id name slug } images { url alt } } } pageInfo { hasNextPage endCursor } } }

Architecture

mcp-graphql-generator/ ├── src/ │ ├── cli.ts # Command line interface │ ├── app.ts # HTTP server entry point │ ├── generators/ │ │ └── genericQueryGenerator.ts # Core query generation logic │ ├── services/ │ │ ├── graphqlIntrospection.ts # API discovery service │ │ └── keycloakAuth.ts # Authentication service │ ├── mcp/ │ │ └── server.ts # MCP protocol server │ ├── config/ │ │ └── credentials.ts # Credential management │ └── types/ │ ├── auth.ts # Authentication types │ └── env.d.ts # Environment types ├── mcp-server.ts # MCP server entry point ├── install-global.ps1 # Global VS Code installation ├── configure-autostart.ps1 # Auto-start configuration ├── docker-compose.global.yml # Docker deployment └── docs/ # Additional documentation

Docker Deployment

# docker-compose.yml version: '3.8' services: mcp-server: build: . ports: - "3001:3001" environment: - GRAPHQL_API_URL=https://your-api.example.com/graphql - API_TOKEN=your_token restart: unless-stopped

# Deploy with Docker docker-compose up -d # Or with Docker directly docker build -t mcp-graphql-generator . docker run -p 3001:3001 -e GRAPHQL_API_URL=https://your-api.com/graphql mcp-graphql-generator

API Compatibility

Works with any GraphQL API that supports introspection, including:

✅ Apollo Server - Full compatibility
✅ GraphQL Yoga - Full compatibility
✅ Hasura - Including metadata queries
✅ Postgraphile - Auto-generated CRUD
✅ AWS AppSync - With custom resolvers
✅ Shopify Admin API - E-commerce queries
✅ GitHub GraphQL API - Repository data
✅ Strapi GraphQL - Headless CMS
✅ Contentful - Content management
✅ Custom GraphQL APIs - Any introspection-enabled API

Development

Setup Development Environment

# Clone repository git clone https://github.com/marias1lva/mcp-graphql-generator.git cd mcp-graphql-generator # Install dependencies bun install # Copy environment template cp .env.example .env # Edit .env with your test GraphQL API # Start in development mode bun --watch mcp-server.ts # Run CLI in development bun --watch src/cli.ts list # Build for production bun build # Run tests (when implemented) bun test

Project Scripts

{ "scripts": { "start": "bun src/app.ts", "dev": "bun --watch mcp-server.ts", "build": "bun build", "cli": "bun src/cli.ts", "cli:list": "bun src/cli.ts list", "cli:interactive": "bun src/cli.ts interactive" } }

Contributing

We welcome contributions! Here's how to get started:

Fork the repository
Create your feature branch (git checkout -b feature/amazing-feature)
Make your changes with proper TypeScript types
Test your changes with a real GraphQL API
Commit your changes (git commit -m 'Add amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request

Contribution Guidelines

TypeScript - All code must be properly typed
Bun - Use Bun for package management and runtime
Testing - Include tests for new features
Documentation - Update README and inline docs
Code Style - Follow existing patterns

License

This project is licensed under the MIT License - see the LICENSE file for details.

Acknowledgments

Bun - For blazing fast JavaScript runtime
Model Context Protocol - For VS Code integration standard
GraphQL - For the amazing query language
GitHub Copilot - For AI-powered development
TypeScript - For type safety and developer experience

⭐ Star this repo if it helped you! ⭐

MCP GraphQL Query Generator