grok-mcp

# Add the plugin marketplace
/plugin marketplace add mortenbrudvik/ClaudeGrokMcp

# Install the plugin
/plugin install grok-mcp@grok-mcp-dev

# Restart Claude Code

export XAI_API_KEY=xai-your-key-here

$env:XAI_API_KEY = "xai-your-key-here"

set XAI_API_KEY=xai-your-key-here

/config set PLUGIN_ENV_XAI_API_KEY=xai-your-key-here

"Ask Grok what the best practices are for error handling in TypeScript"

"Have Grok analyze this function for bugs"

"What does Grok think about this architecture?"

# Simple query
/grok What is the time complexity of merge sort?

# Specify model
/grok --model fast Explain what a mutex is

# Code analysis
/grok --model code Review this function: function add(a,b) { return a-b }

# Extended reasoning
/grok --model reasoning Think through microservices vs monolith trade-offs

{
  query: string,           // Required: The question to ask
  model?: string,          // Model alias or ID (default: "auto")
  context?: string,        // System context to guide response
  max_tokens?: number,     // Max response tokens (default: 4096)
  temperature?: number,    // Sampling temperature 0-2 (default: 0.7)
  image_url?: string,      // Image URL or base64 data URI for vision
  image_detail?: string    // Detail level: "auto", "low", "high"
}

{
  code: string,            // Required: The code to analyze
  language?: string,       // Programming language (auto-detected)
  analysis_type?: string,  // "performance", "bugs", "security", "style", "all"
  context?: string,        // Additional context about the code
  model?: string           // Model to use (default: grok-code-fast-1)
}

{
  query: string,           // Required: The problem to reason through
  effort?: string,         // "low", "medium", "high" (default: "medium")
  show_thinking?: boolean, // Include reasoning trace (default: true)
  context?: string,        // Additional context
  model?: string           // Model to use (default: grok-4-1-fast-reasoning)
}

{
  query: string,           // Required: The query to estimate
  model?: string,          // Model to use (default: auto)
  context?: string,        // Additional context
  max_tokens?: number      // Expected output tokens
}

{
  code: string,            // Required: Python code to execute
  description?: string,    // What the code should accomplish
  include_output?: boolean,// Include stdout/stderr (default: true)
  max_turns?: number,      // Max iterations 1-10 (default: 3)
  model?: string           // Model to use (default: grok-4-1-fast)
}

{
  query: string,              // Required: Search query
  enable_x_search?: boolean,  // Search X/Twitter (default: true)
  enable_web_search?: boolean,// Search web (default: false)
  x_handles?: string[],       // Filter by X handles
  from_date?: string,         // Start date filter
  to_date?: string,           // End date filter
  include_citations?: boolean // Include source citations (default: true)
}

{
  query: string,           // Required: Question about the file
  file_content: string,    // Required: File content as text
  filename?: string,       // Original filename for format detection
  file_type?: string,      // "code", "text", "markdown", "json", "csv", "xml", "yaml"
  context?: string,        // Additional context
  model?: string,          // Model to use
  max_tokens?: number,     // Max response tokens (default: 4096)
  temperature?: number     // Sampling temperature (default: 0.7)
}

{
  refresh?: boolean  // Force refresh from API (default: false)
}

{
  include_details?: boolean  // Include detailed breakdown (default: false)
}

{
  prompt: string,            // Required: Text description of image to generate
  n?: number,                // Number of images 1-10 (default: 1)
  model?: string,            // Model to use (default: grok-2-image-1212)
  response_format?: string   // "url" or "b64_json" (default: "url")
}

[Grok's response]

---
Model: grok-4-fast
Tokens: 150 in / 342 out (492 total)
Cost: $0.0002
Response time: 1234ms

/grok --model code Review this function:

function fibonacci(n) {
  if (n <= 1) return n;
  return fibonacci(n - 1) + fibonacci(n - 2);
}

Ask Grok to analyze the trade-offs between using Redis vs Memcached for session storage

I want both your perspective and Grok's on whether to use TypeScript strict mode

cd mcp
npm install
npm run build

grok-mcp/
├── .claude-plugin/
│   ├── plugin.json        # Plugin manifest
│   └── marketplace.json   # Dev marketplace
├── skills/
│   └── using-grok/
│       └── SKILL.md       # Natural language skill
├── commands/
│   ├── query.md           # /grok-mcp:query command
│   ├── review-with-grok.md # /grok-mcp:review-with-grok
│   ├── debug-with-grok.md  # /grok-mcp:debug-with-grok
│   └── design-review.md    # /grok-mcp:design-review
├── mcp/
│   ├── package.json
│   ├── tsconfig.json
│   └── src/
│       ├── index.ts       # MCP server entry
│       ├── client/
│       │   └── xai-client.ts
│       ├── services/      # Cache, cost tracking, rate limiting
│       ├── tools/
│       │   ├── query.ts   # grok_query tool
│       │   ├── models.ts  # grok_models tool
│       │   ├── analyze-code.ts
│       │   ├── reason.ts
│       │   └── ...        # 10 tools total
│       └── types/
│           └── index.ts
└── README.md

/config set PLUGIN_ENV_XAI_API_KEY=xai-your-key-here