Click on "Deploy 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., "@AL-Go MCP Server How to set up AL-Go CI/CD for my app?"
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.
A Model Context Protocol (MCP) server that provides intelligent access to AL-Go documentation, workflows, and domain expertise for Business Central development automation.
🔗 GitHub Repository: https://github.com/louagej/al-go-mcp-server 📦 npm Package: https://www.npmjs.com/package/al-go-mcp-server
Related MCP server: FO Semantic MCP Server
Domain Specialists: 16 AL-Go expert profiles covering every major workflow area (app creation, CI/CD, release management, testing, deployment, and more)
Knowledge Integration: Links specialists to AL-Go scenarios, workshop content, GitHub Discussions, and resolved Issues
Semantic Search: Cross-source intelligent search with TF-IDF relevance ranking across all knowledge sources
Knowledge Graph: Visualize relationships between specialists and knowledge sources, with cluster detection
Smart Caching: Per-source TTL caching (workshop/scenario: 24h, discussion: 6h, issue: 12h) with hit/miss statistics
AL-Go Documentation: Search through comprehensive AL-Go guides and workflow templates
Optional Authentication: GitHub token support for higher rate limits and full API access
# Install globally for command line usage
npm install -g al-go-mcp-server
# Or use directly with npx (no installation required)
npx al-go-mcp-serverYou can configure the AL-Go MCP server in two ways:
Add to your User MCP Configuration for access across all projects in the same VS Code profile:
Note: User settings are profile-specific. The server will be available for all projects opened with the same VS Code profile (e.g., "Node.js", "Default", etc.).
Open VS Code Command Palette (Ctrl+Shift+P)
Run "MCP: Open User Configuration"
Add the server configuration:
{
"servers": {
"al-go-docs": {
"type": "stdio",
"command": "npx",
"args": ["--yes", "al-go-mcp-server@latest"]
}
},
"inputs": []
}Add to your project's .vscode/mcp.json for project-specific configuration:
{
"servers": {
"al-go-docs": {
"type": "stdio",
"command": "npx",
"args": ["--yes", "al-go-mcp-server@latest"]
}
}
}Provide a GitHub token for higher rate limits, and to enable discussion and issue search:
{
"servers": {
"al-go-docs": {
"type": "stdio",
"command": "npx",
"args": ["--yes", "al-go-mcp-server@latest"],
"env": {
"GITHUB_TOKEN": "your_github_token_here"
}
}
}
}# If installed globally
al-go-mcp-server
# Or using npx (no installation needed, always latest)
npx --yes al-go-mcp-server@latestTool | Description |
| Search AL-Go documentation and guides |
| Get AL-Go workflow templates and examples |
| Force refresh of cached documentation |
Tool | Description |
| Find domain specialists by keyword, persona name, or expertise area |
| Browse all 16 AL-Go domain specialists |
| Get detailed profile for a specific specialist |
| Ask a specialist by persona name — routes your question with avatar context |
Tip: Address specialists directly in chat:
@alg-freddy my dev environment can't be reached— Copilot will callalg-askand Freddy responds with his avatar and expertise.
Tool | Description |
| Fetch AL-Go scenario files from the repository |
| Search GitHub Discussions for community Q&A |
| Search resolved GitHub Issues for tips and workarounds |
| Get all knowledge sources linked to a specialist |
| Build the complete specialist–knowledge graph |
Tool | Description |
| Cross-source intelligent search with relevance ranking |
| Visualize specialist relationships (JSON or text format) |
| View cache hit/miss rates and TTL configuration |
| Clear all, expired, or source-specific cache entries |
Note: Tools in the Knowledge Sources and Advanced groups that call the GitHub API require a
GITHUB_TOKENto be set for full functionality.
The server includes 16 AL-Go domain specialists, each with mapped expertise, keywords, related scenarios, and related workflows:
Disclaimer: All persona names and avatars are randomly generated and entirely fictional. They do not represent, depict, or refer to any real person, living or deceased. Any resemblance to actual individuals is purely coincidental.
Name | Specialist | Focus Area | Sample Chat |
Freddy | Online Dev Environment Specialist | Create and manage cloud-based dev environments |
|
Riley | Release Manager Specialist | Handle release creation and versioning strategies |
|
Drew | Documentation Publisher Specialist | Deploy and manage reference documentation |
|
Vera | Version Updater Specialist | Manage version number increments and semantic versioning |
|
Ethan | Environment Publisher Specialist | Publish Business Central apps to environments |
|
Tara | Current Version Test Specialist | Run and manage tests against the current version |
|
Axel | App Provisioner Specialist | Add and manage existing or test applications |
|
Casey | CI/CD Architect Specialist | Configure and optimize CI/CD pipelines |
|
Grace | App Generator Specialist | Create new BC applications from templates |
|
Perry | Performance Test Creator Specialist | Create and manage performance test applications |
|
Tommy | Test App Creator Specialist | Create test applications for quality assurance |
|
Blake | PR Build Engineer Specialist | Manage pull request build workflows and validation |
|
Finn | Future Version Tester Specialist | Test applications against next major/minor versions |
|
Rex | Troubleshooting Specialist | Diagnose and resolve AL-Go issues and problems |
|
Stella | System File Updater Specialist | Update and maintain AL-Go system files |
|
Bruno | Build Manager Specialist | Manage AL-Go project builds and configurations |
|
# Clone the repository
git clone https://github.com/louagej/al-go-mcp-server.git
cd al-go-mcp-server
# Install dependencies
npm install
# Build the project
npm run build
# Run tests
npm test
# Run locally
npm startWe welcome contributions from the community! This project is open source and we appreciate all kinds of contributions.
Fork the repository and clone it locally
Install dependencies: npm install
Build the project: npm run build
Run tests: npm test — all tests must pass before submitting a PR
Make your changes following our contribution guidelines
Submit a pull request with a clear description
Please read our CONTRIBUTING.md for detailed information about:
Development setup and workflow
Code style and standards
Pull request process
Security guidelines
Review process
For security-related issues, please review our Security Policy and report vulnerabilities responsibly.
Bug Reports: Use the issue template and provide detailed reproduction steps
Feature Requests: Describe the feature and its use case clearly
Questions: Use GitHub Discussions for general questions
MIT — see LICENSE file for details.
Links:
Consult an AL-Go domain specialist for expert guidance on AL-Go workflows, CI/CD pipelines, releases, testing, and Business Central app development. Auto-selects the best specialist based on your question, or use the specialist parameter to request a specific persona (e.g. 'freddy', 'casey', 'rex'). Use this whenever the user asks about AL-Go or addresses a specialist directly (e.g. '@alg-freddy ...', 'alg-freddy ...', 'ask riley about releases').
| Name | Required | Description | Default |
|---|---|---|---|
| question | Yes | The question or problem to bring to the specialist | |
| specialist | No | Optional persona name or handle (e.g. 'freddy', '@alg-freddy', 'alg-riley'). Auto-selects best specialist if omitted. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses auto-selection of the best specialist and the optional specialist parameter for specific personas. However, it does not describe the nature of the answer (e.g., AI-generated or human-like), potential limitations, or any side effects of consultation.
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?
Three sentences, each serving a distinct purpose: stating the tool's role, explaining behavior, and giving usage triggers. No redundant or filler content.
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?
The description covers purpose, usage, and parameter behavior well. However, since there is no output schema, it omits any indication of what the specialist returns (e.g., answer format, length, or whether it's a conversation). This gap reduces completeness for the 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?
Schema coverage is 100% with basic descriptions. The description adds value by explaining that the specialist is auto-selected if omitted and provides example values for the specialist parameter (e.g., 'freddy', 'casey', 'rex'), which clarifies usage beyond the schema.
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: consulting an AL-Go domain specialist for expert guidance on specific topics like workflows, CI/CD, releases, testing, and app development. It distinguishes the tool from siblings by emphasizing specialized AL-Go knowledge and auto-selection of specialists.
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 explicitly says 'Use this whenever the user asks about AL-Go or addresses a specialist directly' and provides concrete examples of how to invoke the specialist (e.g., '@alg-freddy'). However, it does not explicitly mention when not to use the tool or suggest alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Initialize and build the knowledge graph linking specialists to all knowledge sources
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description only mentions initialization and building without disclosing side effects, idempotency, duration, or whether it can be safely rerun.
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, well-formed sentence that efficiently conveys the core purpose without unnecessary words.
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 no output schema and no annotations, the description fails to explain return values, prerequisites, or behavioral context (e.g., is it a one-time setup? Mutates state?). Incomplete for safe agent use.
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?
There are no parameters, and the schema already indicates this. The description adds no extra parameter meaning, but baseline 4 is appropriate for zero-parameter tools.
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 'initialize and build' and the resource 'knowledge graph', and specifies linking specialists to knowledge sources, distinguishing it from sibling search and visualization tools.
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 on when to use this tool versus alternatives (e.g., refreshing cache or searching). No prerequisites or scenarios provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get cache hit rates and statistics for knowledge sources
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description implies a read-only operation but does not explicitly state it is non-destructive; with no annotations, more context about safety and side effects would be helpful.
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?
Single sentence, direct, front-loaded with key information; no wasted words.
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?
For a simple tool with no parameters and no output schema, the description covers the essential purpose; however, it could specify the scope of 'knowledge sources' (all or current) for full completeness.
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?
No parameters exist; baseline 4 applies, and the description adds no unnecessary detail.
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 (get) and the resource (cache hit rates and statistics for knowledge sources), distinguishing it from sibling tools like alg-clear-cache and alg-refresh-cache.
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 on when to use this tool versus alternatives; no mention of when not to use it or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Clear cached knowledge sources or entire cache
| Name | Required | Description | Default |
|---|---|---|---|
| source | No | Cache source to clear | all |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must fully disclose behavior. It only says 'Clear' but doesn't explain effects like irreversibility, impact on users, permission requirements, or what is destroyed. This is a significant gap for a potentially destructive 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 short sentence, concise and to the point. No unnecessary words, but could be more informative. It is appropriately front-loaded.
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 simple structure (1 optional param, no output schema, 100% schema coverage), the description is adequate but minimal. It does not explain behavior for different enum values or return values. Sibling tools related to cache add context, but description could be more complete.
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?
Schema description coverage is 100% (only parameter described). The description adds 'Cache source to clear' which is consistent with the schema. Since coverage is high, baseline is 3; the description does not add substantial new meaning beyond the schema.
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 'Clear cached knowledge sources or entire cache' clearly states the action (clear) and the resource (cached knowledge sources), with the ability to target specific sources or all. The enum options in the schema further specify the exact sources. This distinguishes it from sibling tools like alg-cache-stats (statistics) and alg-refresh-cache (refresh).
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. There is no mention of prerequisites, when clearing cache is appropriate, or what to consider before clearing. The description lacks context for decision-making.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get available AL-Go setup scenarios
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description should disclose behavioral traits. It only states what the tool does (gets scenarios) without mentioning idempotency, side effects, caching, or permissions.
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 short sentence that immediately conveys the tool's purpose. There is no unnecessary information, earning its place.
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?
For a parameterless tool, the description is minimally complete. However, it lacks any hint about the output format or what 'scenarios' means, given no output schema.
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?
There are zero parameters, so schema description coverage is 100%. Baseline is 4; the description does not add parameter semantics, but none are needed.
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 'Get' and the resource 'available AL-Go setup scenarios', making the purpose obvious. No sibling tool targets scenarios, so differentiation is not an issue.
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 like search tools or list tools. The description does not mention any prerequisites or context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get version information for the AL-Go MCP server
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Description is minimal and does not disclose behavioral traits such as idempotency or read-only nature. Since no annotations exist, the description carries full burden but only states purpose.
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?
Single sentence, front-loaded with the core action. No unnecessary words.
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?
For a parameterless version information retrieval, the description is sufficiently complete. No output schema is needed as output is simple version string.
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?
No parameters exist, and schema coverage is 100%. Baseline score of 4 applies as description adds no extra semantic value beyond the schema, which is sufficient.
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?
Description clearly states the action ('Get version information') and the resource ('AL-Go MCP server'), distinguishing it from sibling tools that handle specialists, discussions, etc.
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 explicit guidance on when to use this tool versus alternatives. Usage is implied for retrieving server version, but no exclusions or context are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get detailed information about a specific AL-Go specialist
| Name | Required | Description | Default |
|---|---|---|---|
| specialistId | Yes | The ID of the specialist (e.g., 'alg-casey', 'alg-grace') |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. However, it only states 'get detailed information' without disclosing what fields or data are returned, or any side effects. For a read operation, it lacks detail about output or invariants.
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 sentence, concise and front-loaded. It has no wasted words but could be slightly more descriptive without sacrificing brevity.
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?
No output schema exists, so the description should explain the return value. It fails to describe what 'detailed information' includes, leaving the agent uninformed about the response.
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?
Schema coverage is 100% with a single parameter 'specialistId' well-described in the schema. The description does not add anything beyond what the schema provides, so baseline score applies.
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 ('get') and the resource ('detailed information about a specific AL-Go specialist'). It is specific and distinguishes well from siblings like search and list tools.
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 implies you should use this when you have a specific specialistId, but it does not explicitly state when to use it versus alternatives or provide any exclusions. The context is implied but not elaborated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get comprehensive knowledge for a specialist including workshops, scenarios, discussions, and issues
| Name | Required | Description | Default |
|---|---|---|---|
| specialistId | Yes | The ID of the specialist |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description must disclose behavioral traits. It does not mention read-only nature, error handling, response format, or any rate limits. The description is minimal.
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 sentence that directly states the purpose. It is concise, though the word 'comprehensive' is vague. Still, it communicates the core action efficiently.
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 lack of output schema and annotations, the description should provide more context on return structure, usage scenarios, or limitations. It only lists content categories without clarifying how the data is presented or what to expect.
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?
Schema coverage is 100% and the schema describes the parameter 'specialistId' adequately. The description adds no additional meaning beyond the schema, meeting the baseline for high coverage.
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 gets comprehensive knowledge for a specialist, listing specific content types (workshops, scenarios, discussions, issues). It distinguishes itself from sibling tools like 'alg-get-specialist' (likely basic info) and various search tools.
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 such as 'alg-search-specialists' or 'alg-get-specialist'. No exclusions or context are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get examples of AL-Go GitHub workflows
| Name | Required | Description | Default |
|---|---|---|---|
| workflowType | No | Type of workflows to retrieve | all |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must convey behavioral traits. It only states the action without disclosing whether it's read-only, any side effects, or response characteristics. This is insufficient for safe invocation.
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, concise sentence that directly states the tool's function. It avoids unnecessary words but is not overly verbose.
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 lack of output schema and annotations, the description should provide more context about the returned examples (e.g., format, scope). It is too minimal for a fully autonomous agent to understand the tool's behavior.
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?
Schema coverage is 100% as the single parameter 'workflowType' includes an enum and description. The description adds no extra meaning beyond the schema, so baseline score of 3 is appropriate.
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 retrieves examples of AL-Go GitHub workflows. The verb 'Get' and resource 'workflows' are specific, and the title reinforces this. Among siblings like search and specialist tools, this tool's purpose is distinct.
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 vs. alternatives such as alg-get-scenarios or alg-search-issues. The description lacks explicit context for optimal usage or exclusion criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get knowledge graph structure for visualization (nodes and edges)
| Name | Required | Description | Default |
|---|---|---|---|
| format | No | Output format | json |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavioral traits. It only indicates a read operation (get) but omits details on side effects, authentication requirements, rate limits, or behavior with empty graphs. The single sentence is insufficient for a tool with no annotation support.
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 very concise at 10 words, but it lacks necessary details about the output structure or usage context. While front-loaded, it is too sparse for a tool that would benefit from more explanation.
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 simplicity (one optional parameter, no output schema), the description fails to explain the output format (e.g., structure of nodes and edges) or any constraints. Users are not told what the returned data looks like.
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?
Schema coverage is 100%, with one parameter 'format' well-defined by enum values. The description adds no additional meaning beyond the schema, so a baseline score of 3 is appropriate.
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 gets a knowledge graph structure for visualization, specifying nodes and edges. It distinguishes from siblings like alg-build-knowledge-graph by its focus on retrieval for visualization, but does not explicitly differentiate from alg-get-specialist-knowledge.
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, such as alg-build-knowledge-graph or alg-get-specialist-knowledge. There is no mention of prerequisites, like whether the graph needs to be built first.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all available AL-Go specialists and their persona names. After browsing, use alg-ask with the specialist parameter to connect with a specific specialist.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries burden. States output is a list of specialists and persona names. Does not disclose ordering, dynamism, or any side effects. Adequate for a read-only list tool.
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?
Two sentences, zero waste. Front-loaded with purpose, followed by actionable guidance. Each sentence earns its place.
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 no parameters, no output schema, and sibling tools, description covers purpose, content of output, and next steps. Slight lack of behavioral details but complete for a simple list tool.
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?
No parameters exist; schema coverage is 100%. Description adds no param info, but none is needed. Baseline is high due to trivial schema.
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?
Verb 'List' with resource 'all available AL-Go specialists and their persona names' is specific and clear. It distinguishes from sibling tools like alg-search-specialists (search) and alg-get-specialist (get specific).
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?
Explicitly states when to use: to browse all specialists. Provides clear next step: use alg-ask with the specialist parameter. Does not explicitly exclude other tools but context implies differentiation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Refresh the cached AL-Go documentation from the repository
| Name | Required | Description | Default |
|---|---|---|---|
| force | No | Force refresh even if cache is recent |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description bears the full burden of disclosing behavioral traits. It only states the action without explaining specifics like whether the operation is blocking, if it invalidates existing cached data, or how it determines whether a refresh is needed. The presence of a 'force' parameter implies some behavior but is not described.
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 sentence that conveys the core purpose without extraneous words. It is front-loaded and efficient, though it could possibly add a bit more context without losing conciseness.
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?
For a simple cache refresh tool with one optional parameter and no output schema, the description is minimally adequate. However, it lacks behavioral details and usage guidance that would make it fully complete given the context of sibling tools and typical usage patterns.
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?
Schema coverage is 100% (the 'force' parameter is fully described in the schema). The description does not add extra meaning beyond what the schema already provides, so the baseline score of 3 is appropriate.
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 uses the specific verb 'Refresh' and identifies the resource as 'cached AL-Go documentation from the repository', clearly indicating the tool's action and scope. It naturally distinguishes from sibling tools like alg-clear-cache, which removes the cache entirely, by implying a reload operation.
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 such as alg-clear-cache or when the cache might need refreshing. It does not mention prerequisites, typical use cases, or situations where the tool should be avoided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search for relevant discussions in the AL-Go repository
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Maximum number of results to return | |
| query | Yes | Search query for discussions |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description must cover behavioral traits. It only says 'Search for relevant discussions' without disclosing read/write nature, API used, result ordering, rate limits, or any side effects. This is insufficient for understanding tool behavior.
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?
Single sentence is concise and front-loads the purpose. No unnecessary words, but could be slightly more informative without becoming verbose.
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?
Description is minimal for a search tool with no output schema and no annotations. It omits important context such as expected response format, query syntax limitations, or how results are ordered. Comparatively, sibling tools may have richer descriptions.
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?
Schema coverage is 100%, with both parameters adequately described in the schema (query and limit). Description adds no additional semantic value beyond the schema, so baseline score of 3 is appropriate.
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?
Description clearly states 'Search for relevant discussions in the AL-Go repository', specifying the action (search), resource (discussions), and scope (AL-Go). It naturally distinguishes from siblings like alg-search-issues and alg-search-docs.
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 on when to use alg-search-discussions versus alternatives like alg-search-issues or alg-search-docs. Missing information about when not to use, prerequisites, or context for choosing this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search through AL-Go documentation for specific queries
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Maximum number of results to return | |
| query | Yes | Search query for AL-Go documentation |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description bears full responsibility for behavioral disclosure. It fails to mention that the tool is read-only or any other behavioral traits, leaving the agent uninformed about side effects or constraints.
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, concise sentence that efficiently communicates the purpose with no superfluous words.
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 has no output schema and no annotations, the description should provide more context about result format, sorting, pagination, or scope. It is incomplete for an effective agent invocation.
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?
Schema coverage is 100%, so the baseline is 3. The description adds no extra meaning beyond what is already in the schema for the parameters.
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 (search) and the resource (AL-Go documentation), effectively distinguishing from sibling tools that search other resources like specialists, discussions, or issues.
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 such as alg-semantic-search or alg-search-discussions. No exclusions or context for when not to use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search for tips and tricks in resolved AL-Go issues
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Maximum number of results to return | |
| query | Yes | Search query for issues |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavioral traits. It only states the basic function without mentioning pagination, result ordering, rate limits, or what happens with no results. This is insufficient for a search tool.
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 short sentence, which is concise. However, it omits critical information that could be included without verbosity, making it under-specified.
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 no output schema and no annotations, the description should compensate with more details about return format, ordering, and constraints. It fails to do so, leaving the tool's behavior ambiguous.
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?
Schema coverage is 100%, so the schema already describes both parameters adequately. The description adds no additional meaning or context beyond the schema, meeting the baseline but not exceeding it.
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?
Description states verb 'search' and resource 'resolved AL-Go issues' with purpose 'tips and tricks'. Clearly identifies action and scope, though does not explicitly distinguish from sibling tools like alg-search-discussions or alg-search-docs.
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?
Description provides no guidance on when to use this tool versus alternatives, no when-not-to-use conditions, and no mention of prerequisites or context. The agent is left to infer usage from the name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search for AL-Go specialists by name, persona, expertise, or keyword
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search query (specialist name, persona name, expertise, or keyword) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Since no annotations exist, the description must fully disclose behavior. It only states the search operation, but omits details about output format, result limits, pagination, or rate limits. This is insufficient for an agent to understand side effects.
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 sentence that conveys the core functionality without any unnecessary words. It is well-structured and front-loaded.
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 simplicity (one parameter, no output schema), the description is minimal. However, it lacks details on what the search returns (e.g., list of specialist objects) and how to interpret results. Sibling tools are numerous, and the description does not help distinguish them.
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?
Schema description coverage is 100% for the single parameter. The description adds context by listing searchable fields (name, persona, expertise, keyword), but this closely mirrors the schema's description. Given high schema coverage, baseline of 3 is appropriate.
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 'search' and the resource 'AL-Go specialists', mentioning searchable attributes. However, it does not differentiate from sibling tools like alg-search-discussions or alg-search-issues, which also perform searches over different resources.
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 vs alternatives such as alg-list-specialists or alg-get-specialist. There is no mention of use cases or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Intelligent cross-source search across workshops, scenarios, discussions, and issues using relevance scoring
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Maximum results to return | |
| query | Yes | Search query |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description only mentions 'relevance scoring' but omits other behavioral traits such as read-only status, authentication requirements, query handling (e.g., empty query), or result ordering details. The transparency is minimal.
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 sentence that front-loads the key purpose and scope. Every word contributes, with no redundancy or unnecessary elaboration.
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 has no output schema, the description should explain what the output includes (e.g., results from each source, scores). It lacks this. Additionally, with many sibling tools, more guidance on when to choose this over specific searches would improve completeness.
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?
Schema description coverage is 100%, so the schema already documents both parameters (query and limit). The description adds 'intelligent cross-source search' and 'relevance scoring' context but does not enrich parameter meaning beyond what the schema provides. Baseline 3 is appropriate.
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 it performs intelligent cross-source search across workshops, scenarios, discussions, and issues using relevance scoring. It distinctly separates from sibling tools like alg-search-specialists (specialists only) and alg-search-discussions (discussions only) by emphasizing multiple sources.
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 implies usage when a cross-source search is needed ('cross-source search'), but does not explicitly state when not to use it or provide alternatives. Given the sibling tools for specific sources, the context is implicit but not explicit.
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.
v2.8.0alg-askalg-build-knowledge-graphalg-cache-statsalg-clear-cachealg-get-scenariosalg-get-server-versionalg-get-specialistalg-get-specialist-knowledgealg-get-workflowsalg-graph-visualizationalg-list-specialistsalg-refresh-cachealg-search-discussionsalg-search-docsalg-search-issuesalg-search-specialistsalg-semantic-searchScored across 17 tools
There is significant overlap among specialist-related tools (search, list, get, ask, get-knowledge) and search tools (discussions, issues, docs, semantic). Descriptions help differentiate but agents may still struggle to choose correctly.
All tools use 'alg-' prefix followed by verb_noun pattern. Slight inconsistency with compound verbs like 'build-knowledge-graph' and 'graph-visualization', but overall consistent.
17 tools is on the higher side but justifiable given the multiple knowledge sources and specialist features. Not excessive.
Covers specialists, discussions, issues, docs, workflows, and cache management. Semantic search bridges sources. Minor gap: no direct tool to execute or trigger workflows.
Versioned documentation registry and semantic search for AI tools and coding assistants.
Ask any GitHub repository a question. Get source-backed answers.
AI colleagues that keep your standards, your project and their reasoning between sessions
Connect AI assistants to your GitHub-hosted Obsidian vault to seamlessly access, search, and analy…
