Enables consultation with GPT models for technical advice, code reviews, architecture guidance, and complex problem-solving through the OpenAI API.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Senior Consult MCP review this authentication flow for security issues"
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.
Let your AI agent consult top-tier models for expert technical guidance.
An MCP server that connects your AI agent to expert models (Claude, GPT, Gemini, DeepSeek, Z.ai) for architectural advice, code reviews, and complex problem-solving.
Your AI agent is great, but sometimes it needs a second opinion. This MCP server lets it consult specialized models for high-stakes decisions without switching context.
Related MCP server: Task Agents
Tool | Description |
ask_senior | General technical consultation |
code_review | Security, performance & quality checks |
architecture_advice | System design guidance |
reset_history | Clear conversation memory |
Add to your MCP settings (Claude Desktop, Cursor, Windsurf, etc.):
{
"mcpServers": {
"senior-consult": {
"command": "npx",
"args": ["-y", "senior-consult-mcp"],
"env": {
"ANTHROPIC_API_KEY": "your-key"
}
}
}
}"Ask senior to review this authentication flow for security issues"
"Get architecture advice on microservices vs monolith for our scale"
"Code review this function for potential memory leaks"
Option A: npx (Recommended)
# No install needed - runs directly
npx -y senior-consult-mcpOption B: Global
npm install -g senior-consult-mcpOption C: Local Development
git clone https://github.com/silkyland/senior-consult-mcp.git
cd senior-consult-mcp
npm install
npm run build
npm startSet at least one provider key:
ANTHROPIC_API_KEY=sk-ant-... # Claude
OPENAI_API_KEY=sk-... # GPT
GEMINI_API_KEY=... # Gemini
DEEPSEEK_API_KEY=sk-... # DeepSeek
ZAI_API_KEY=... # Z.ai (or ZHIPU_API_KEY)
OPENAI_COMPATIBLE_API_KEY=... # Custom endpointOverride default models:
# Claude
CLAUDE_MODEL=claude-sonnet-4-5
CLAUDE_URL=https://api.anthropic.com/v1/messages
# OpenAI
OPENAI_MODEL=gpt-4o
OPENAI_URL=https://api.openai.com/v1/chat/completions
# Gemini
GEMINI_MODEL=gemini-2.5-flash
# DeepSeek
DEEPSEEK_MODEL=deepseek-chat
DEEPSEEK_URL=https://api.deepseek.com/chat/completions
# Z.ai
ZAI_MODEL=glm-4-plus
ZAI_URL=https://open.bigmodel.cn/api/paas/v4/chat/completions
# Custom OpenAI-compatible
OPENAI_COMPATIBLE_MODEL=your-model
OPENAI_COMPATIBLE_URL=https://your-endpoint/v1/chat/completions{
"mcpServers": {
"senior-consult": {
"command": "npx",
"args": ["-y", "senior-consult-mcp"],
"env": {
"ANTHROPIC_API_KEY": "sk-ant-xxx",
"DEEPSEEK_API_KEY": "sk-xxx",
"GEMINI_API_KEY": "xxx",
"CLAUDE_MODEL": "claude-sonnet-4-5",
"DEEPSEEK_MODEL": "deepseek-reasoner"
}
}
}
}Multi-Provider - Claude, GPT, Gemini, DeepSeek, Z.ai, custom endpoints
Smart Memory - Token-aware history with auto-trimming
Optimized Prompts - Tuned for concise, actionable advice
Zero Config - Works out of the box with sensible defaults
We welcome contributions! Here's how you can help:
Report bugs - Open an issue with reproduction steps
Suggest features - Share ideas in discussions
Improve docs - Fix typos, add examples
Submit PRs - Bug fixes, new providers, optimizations
# Clone & install
git clone https://github.com/silkyland/senior-consult-mcp.git
cd senior-consult-mcp
npm install
# Build & test
npm run build
# Run locally
npm startFork the repo
Create feature branch (git checkout -b feature/awesome)
Make changes & add tests
Commit (git commit -m 'Add awesome feature')
Push (git push origin feature/awesome)
Open PR with clear description
TypeScript strict mode
ESLint + Prettier
Meaningful commit messages
Tests for new features
MIT
Questions? Open an issue or start a discussion.
Like this project? Give it a star to show support!
Get architecture and design pattern recommendations from a senior AI.
| Name | Required | Description | Default |
|---|---|---|---|
| problem | Yes | Architecture challenge description |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool provides 'recommendations', implying a read-only or advisory operation, but doesn't clarify aspects like whether it's stateless, if it requires authentication, rate limits, or what the response format might be. For a tool with zero annotation coverage, this is a significant gap, warranting a score of 2.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence: 'Get architecture and design pattern recommendations from a senior AI.' It is front-loaded with the core purpose, has no redundant information, and every word contributes to understanding the tool's function. This earns a perfect score of 5 for conciseness and structure.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (a single-parameter advisory tool), no annotations, and no output schema, the description is minimally complete. It states what the tool does but lacks details on behavioral traits, usage context, or return values. This is adequate for a simple tool but has clear gaps, resulting in a score of 3 as the minimum viable description.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the single parameter 'problem' documented as 'Architecture challenge description'. The description adds no additional meaning beyond this, such as examples or constraints. Given the high schema coverage, the baseline score is 3, as the schema adequately handles parameter semantics without extra value from the description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get architecture and design pattern recommendations from a senior AI.' It specifies the action ('Get recommendations') and the resource type ('architecture and design pattern'), though it doesn't explicitly differentiate from sibling tools like 'ask_senior' or 'code_review', which might also provide advice. This earns a 4 for clear purpose without sibling differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'ask_senior' or 'code_review'. It lacks context about specific scenarios, prerequisites, or exclusions, leaving the agent to infer usage based on the tool name alone. This results in a score of 2 for no explicit usage guidelines.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
General purpose consultation with a senior AI developer mentor.
| Name | Required | Description | Default |
|---|---|---|---|
| question | Yes | The question or problem to solve |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states this is a 'consultation' tool, implying it's likely read-only and non-destructive, but doesn't confirm this or describe any behavioral traits such as response format, latency, rate limits, or authentication needs. For a tool with zero annotation coverage, this is a significant gap in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's appropriately sized and front-loaded, making it easy for an agent to parse quickly. Every part of the sentence earns its place by conveying essential information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (a consultation tool with no annotations and no output schema), the description is incomplete. It doesn't explain what the tool returns (e.g., advice, code snippets, or references), how to interpret responses, or any behavioral context. With zero annotation coverage and no output schema, the description should do more to compensate, but it falls short.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, with the single parameter 'question' documented as 'The question or problem to solve.' The description doesn't add any meaning beyond this, such as examples or constraints on question format. Since the schema does the heavy lifting, the baseline score of 3 is appropriate, as the description doesn't compensate but also doesn't detract.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose as 'General purpose consultation with a senior AI developer mentor,' which specifies the action (consultation) and resource (senior AI developer mentor). It distinguishes from siblings like 'architecture_advice' and 'code_review' by being broader and more general rather than focused on specific domains. However, it doesn't explicitly contrast with 'reset_history,' which might be a different type of tool.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to prefer 'ask_senior' over 'architecture_advice' or 'code_review' (e.g., for general vs. specific questions), nor does it specify any prerequisites or exclusions. This lack of context leaves the agent to guess based on tool names alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Request a code review from a senior AI developer.
| Name | Required | Description | Default |
|---|---|---|---|
| code | Yes | The code to review |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action but doesn't explain what happens during the review (e.g., feedback format, time required, permissions needed, or if it's a one-time or iterative process). This leaves critical behavioral traits unspecified.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's front-loaded and appropriately sized for the simple functionality, with zero waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of a code review tool with no annotations and no output schema, the description is incomplete. It doesn't cover behavioral aspects like response format, error handling, or how it differs from siblings, leaving gaps in understanding the tool's full context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the 'code' parameter documented as 'The code to review'. The description doesn't add any meaning beyond this, such as code length limits or supported languages. Baseline 3 is appropriate since the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Request a code review') and the resource ('from a senior AI developer'), making the purpose understandable. However, it doesn't differentiate from sibling tools like 'ask_senior' or 'architecture_advice', which might involve similar consultation scenarios.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'ask_senior' or 'architecture_advice'. It lacks context about prerequisites, such as whether this is for specific types of code or situations, leaving usage ambiguous.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Clear the conversation memory/history.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. 'Clear' implies a destructive mutation, but the description doesn't specify whether this is reversible, what exactly gets cleared (e.g., all history or selective), or any side effects. It lacks behavioral details beyond the basic action.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence with no wasted words. It's front-loaded with the core action and resource, making it highly efficient and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (a destructive operation with no parameters) and lack of annotations or output schema, the description is incomplete. It doesn't explain what 'clear' entails (e.g., permanent deletion, reset to empty), the scope of 'conversation memory/history', or any confirmation/response behavior, leaving significant gaps for an agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, and schema description coverage is 100% (empty schema). With no parameters, the description doesn't need to add parameter semantics, so a baseline of 4 is appropriate as it's not lacking in this dimension.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Clear') and resource ('conversation memory/history'), making the purpose immediately understandable. It doesn't distinguish from siblings (which appear unrelated), but that's not needed here since siblings are about different domains (architecture, advice, code review).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives or in what context. The description states what it does but offers no usage instructions, prerequisites, or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
architecture_adviceask_seniorcode_reviewreset_historyThe tools have overlapping purposes that could cause confusion, particularly between 'architecture_advice' and 'ask_senior' which both involve consulting a senior AI. However, 'code_review' and 'reset_history' are clearly distinct, and descriptions help differentiate the general consultation from specific architecture advice.
The naming follows a consistent snake_case pattern throughout, with clear verb_noun structures like 'get_architecture_advice' implied. Minor deviations exist, such as 'ask_senior' being less descriptive than others, but overall the conventions are readable and predictable.
With 4 tools, the count is reasonable for a consultation server, covering core functions like advice, review, and history management. It's slightly lean but well-scoped, with each tool earning its place without feeling excessive or insufficient for the domain.
The tool set covers key consultation aspects like advice and code review, but there are notable gaps. For example, there's no tool for follow-up queries or iterative feedback, which could limit agent workflows. The surface is functional but not fully comprehensive for a senior consultation domain.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Coordination hub for AI coding agents: message teammates, ask humans, audit every event.
AI colleagues that keep your standards, your project and their reasoning between sessions
Multi-LLM council: 25+ frontier models in parallel, consensus scoring, verdict-first code review.
Collective memory for AI agents. One agent solves a bug — every agent gets the fix instantly.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/silkyland/senior-consult-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
