An MCP server that gives AI assistants ranked, searchable access to AL-Go documentation, workflows, GitHub community knowledge, and 16 expert domain specialists for Business Central development automation.
Search documentation: query AL-Go guides and docs with BM25 relevance ranking and configurable result limits.
Get workflows: retrieve AL-Go GitHub workflow examples for CI/CD, deployment, testing, or all types.
Work with specialists: list, search, and get detailed profiles for all 16 personas, or ask one directly (alg-ask) with automatic specialist selection.
Search community knowledge: query GitHub Discussions (50 most recent) and resolved Issues (100 most recent) for tips and workarounds.
Fetch scenarios & knowledge: pull AL-Go setup scenarios and all knowledge sources linked to a specialist.
Semantic search: run cross-source intelligent search across workshops, scenarios, discussions, and issues.
Build & visualize a knowledge graph: link specialists to knowledge sources, detect clusters, and output as JSON or stats.
Manage caching: view cache hit/miss stats and TTLs, clear docs/discussion/issue caches, or force a docs re-download.
Check version: report the running server version (plus background npm update checks).
Note: Discussion, issue, and other GitHub API-backed tools require a GITHUB_TOKEN; docs search works without it.
Provides tools for searching AL-Go documentation, workflows, scenarios, and community knowledge by accessing GitHub Discussions and resolved GitHub Issues in the AL-Go repository. A GitHub token enables higher rate limits and full discussion and issue search.
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: Dynamics 365 Business Central Admin 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
Ranked Search: BM25 relevance ranking (with title and path boosts) for documentation, issues, discussions, and cross-source semantic search
Knowledge Graph: Visualize relationships between specialists and knowledge sources, with cluster detection
Smart Caching: One shared cache for all GitHub data (docs: 24h, discussions: 6h, issues: 12h) with hit/miss statistics; documentation is downloaded without using the GitHub API rate limit
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"
}
}
}
}AL_GO_MCP_GITHUB_TOKEN is accepted as an alternative to GITHUB_TOKEN.
Add the server for all your projects:
claude mcp add --scope user al-go-docs -e GITHUB_TOKEN=your_github_token_here -- npx --yes al-go-mcp-server@latestThe 16 specialists can be installed as agents in Claude Code (~/.claude/agents) and VS Code Copilot Chat (your VS Code user prompts folder, e.g. %APPDATA%CodeUserprompts on Windows), so they are available in every project.
Install once from the command line:
npx --yes al-go-mcp-server@latest --install-agents # every client found on this machine
npx --yes al-go-mcp-server@latest --install-agents=claude # Claude Code only
npx --yes al-go-mcp-server@latest --install-agents=vscode # VS Code onlyOr let the server keep them up to date on every start by setting AL_GO_MCP_INSTALL_AGENTS to true, claude or vscode in its env:
"env": {
"AL_GO_MCP_INSTALL_AGENTS": "true"
}Claude Code: restart the session to load new agents. Claude delegates AL-Go questions to the matching specialist on its own, or you can ask for one: use alg-rex to find out why my CI/CD workflow fails. Agents are listed under /agents.
VS Code: the agents appear in the Copilot Chat agent picker as @alg-*. They call the server's tools as al-go-docs/*, so keep al-go-docs as the server name.
At startup the server checks npm for a newer version in the background (a single request with a 3-second timeout; it never delays startup or fails offline). When one is available, the next tool result ends with a one-line notice:
npx with @latest (the configurations above): restarting the MCP server is enough to get the new version.
Global install: the notice shows the npm install -g al-go-mcp-server@latest command to run.
Agent files installed earlier (see Specialist Agents) are rewritten automatically when the server version changes, followed by a notice to restart the Claude Code session or reload the VS Code window. Only clients that already have AL-Go agents are touched, and only the alg-* files.
Set AL_GO_MCP_UPDATE_CHECK to off to disable the update check. The server uses npm_config_registry when it is set, so a company npm mirror works.
# 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 |
| Load the documentation index, or re-download it with |
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. This requires the agent files; see Specialist Agents.
Tool | Description |
| Fetch AL-Go scenario files from the repository |
| Search GitHub Discussions for community Q&A (requires a GitHub token) |
| 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 cached data, or just |
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 GitHub data so the next request re-downloads it. 'docs' covers documentation, scenarios and workshops.
| Name | Required | Description | Default |
|---|---|---|---|
| source | No | Cache source to clear | all |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral burden. It does disclose one real trait — the next request re-downloads, implying a performance cost — but says nothing about permissions, whether the clear is scoped/reversible, or impact on in-flight requests.
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 short sentences, zero padding, with the core effect front-loaded before the enum clarification. Every 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?
For a single-parameter, no-output-schema tool this is nearly sufficient, but with no annotations the description should at least flag that clearing forces a costly re-download and how this differs from alg-refresh-cache and alg-cache-stats. The enum nuance is covered; the operational context is not.
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 baseline is 3, but the description genuinely adds meaning the schema lacks by defining what the 'docs' enum value encompasses (documentation, scenarios, workshops), which is not derivable from the schema's generic 'Cache source to clear'.
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?
'Clear cached GitHub data so the next request re-downloads it' is a specific verb+resource with the consequence spelled out. It doesn't however distinguish itself from the sibling alg-refresh-cache, leaving the clearing-vs-refreshing boundary unstated.
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 clear versus when to use alg-refresh-cache, and no warning about side effects (forced re-download cost, latency). The agent must infer the scenario entirely from the tool name.
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.
Load the AL-Go documentation index (cached for 24 hours). Use force=true to re-download it from the repository.
| Name | Required | Description | Default |
|---|---|---|---|
| force | No | Discard the cached documentation and re-download it |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral burden. It usefully discloses the 24-hour cache TTL and that force=true bypasses it by re-downloading from the repository, but it says nothing about what happens to already-cached data, whether the operation returns the index, or any auth/permission requirements.
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 short sentences, zero waste, with the core behavior front-loaded before the optional-parameter hint. Appropriately sized for a one-parameter tool.
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 single-parameter tool this is adequate but not complete: with no annotations and no output schema, the description should say what the refresh returns or how it interacts with the other cache tools, and it does not.
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 sole parameter is fully documented in the schema. The description restates the force=true behavior without adding format or semantic detail beyond the schema's own description, so the baseline of 3 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?
States a clear verb and resource — loading the AL-Go documentation index — and adds the caching behavior. It never distinguishes itself from the closely related siblings alg-clear-cache or alg-cache-stats, and the name ('refresh') does not quite match the description ('load'), so an agent cannot fully tell it apart from them without guessing.
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 statement of when to call this versus alg-clear-cache, alg-cache-stats, or the search tools. The only guidance offered ('Use force=true to re-download') is parameter-level instruction, not tool-selection guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search the 50 most recently active GitHub Discussions in the AL-Go repository. Requires a GitHub token.
| 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?
With no annotations, the description carries the full burden. It usefully discloses the auth requirement (GitHub token) and the hard corpus bound (only the 50 most recently active discussions), which tells the agent this is not a full-repository search. It omits return shape, ordering, and rate-limit 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?
Two short sentences, front-loaded with the scoping constraint and the auth requirement. Nothing is redundant and no filler is present.
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 two-parameter search tool with no annotations and no output schema, the description covers scope and auth adequately but leaves the result format and ranking behavior unexplained. An agent knows how to call it, but not entirely what to expect back.
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 both parameters are documented in the schema, setting a baseline of 3. The phrase '50 most recently active' clarifies what the limit budget applies to, but no query syntax or matching semantics are given.
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?
States a specific verb (Search) and resource (GitHub Discussions) scoped to the AL-Go repository, which separates it from sibling search tools like alg-search-docs and alg-search-specialists. It does not, however, explicitly distinguish itself from the closest sibling alg-search-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?
Usage is implied by the name and resource, and the description adds a prerequisite (GitHub token required). It never says when to prefer this over alg-search-issues or alg-semantic-search, nor states any exclusion conditions.
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?
No annotations are provided, so the description carries the full disclosure burden, and it discloses nothing behavioral: not that it is a read-only operation, not how results are ranked or returned, not whether it hits a cache (siblings alg-refresh-cache/alg-cache-stats suggest a cached index), and not the truncation behavior of the limit parameter. It is not misleading, but it is essentially bare.
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?
A single tight sentence with no filler and the core purpose front-loaded. Its brevity is appropriate, though it shades into under-specification rather than deliberate economy.
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 search tool with no annotations and no output schema, the description should at minimum describe the result shape, ranking, or how it differs from the other search/ask siblings. None of that is present, so an agent cannot confidently choose or interpret this tool from the definition alone.
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 both the query string and the limit (1-50, default 10) are fully documented in the schema itself. The description adds no extra meaning such as query syntax, matching mode, or what happens when limit exceeds available matches, so the baseline 3 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?
States a specific verb (Search) and resource (AL-Go documentation) with a clear scope, so an agent knows this is a documentation keyword search rather than a general-purpose lookup. It does not, however, distinguish itself from the several sibling search tools (alg-semantic-search, alg-search-specialists, alg-search-discussions, alg-search-issues, alg-ask), leaving the agent to guess which corpus this covers versus those.
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?
There is no when-to-use guidance, no exclusions, and no mention of alternatives despite a crowded sibling set of search/ask tools. The agent gets no signal about whether to prefer this over alg-semantic-search or alg-ask for a given question.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search the 100 most recently closed AL-Go issues for tips and workarounds
| 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?
With no annotations, the description carries the full behavioral burden. It does disclose a meaningful limitation — the corpus is capped at the 100 most recently closed issues, so open issues and older resolutions are invisible — but it says nothing about return format, whether issue links/IDs are included, or any rate/permission 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?
A single front-loaded sentence with no filler; the scope constraint and purpose are both delivered immediately.
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 two-parameter search tool with no annotations and no output schema, the description covers scope but not result shape or search behavior. An agent can invoke it correctly but cannot predict what a result contains or how ranking works.
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 both parameters, so the baseline is 3. The description adds no query syntax, matching behavior, or relevance-ranking detail beyond the schema, and its mention of '100 issues' is in mild tension with the limit parameter's max of 50.
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 gives a specific verb (Search) and resource (AL-Go issues), plus a scope qualifier (100 most recently closed) and a purpose (tips and workarounds). It implicitly distinguishes itself from sibling search tools (alg-search-docs, alg-search-discussions) by naming the issue corpus, though it never routes explicitly to those alternatives.
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?
It hints at when to use it (looking for tips and workarounds), which implies troubleshooting intent, but names no alternatives and gives no when-not guidance despite five sibling search tools existing. Usage is inferred rather than stated.
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, so the description carries the full behavioral burden. 'Relevance scoring' is a mild disclosure about ranking, but it says nothing about latency, index/cache dependency (relevant given alg-refresh-cache and alg-cache-stats siblings), result grouping, or whether results carry source labels.
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?
One front-loaded sentence that identifies the action, scope, and ranking mechanism with no wasted clauses. 'Intelligent' is mild marketing filler, which keeps it from a 5.
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 tool is low-complexity and the input schema is fully self-documented, so the description is close to sufficient. With no output schema, however, it should say something about what comes back (e.g. mixed-source results, relevance ordering, source attribution), and it does not.
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% with only two flat parameters, so the schema already documents 'query' and 'limit' including default 10 and max 50. The description adds no syntax, matching, or filtering guidance beyond that, so the baseline 3 is correct.
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?
Names a specific verb (search) and the resource set (workshops, scenarios, discussions, issues), and 'cross-source' distinguishes it from the single-source siblings alg-search-docs, alg-search-discussions, and alg-search-issues. It stops short of explicitly naming a sibling it is not, so it falls just under the top band.
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?
'Cross-source' implies the tool is for broad searches rather than the per-source siblings, which is useful implicit routing. However, there is no explicit when-to-use statement, no exclusion (e.g. 'do not use for a single known source'), and no mention of the cache/refresh siblings.
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.9.0alg-clear-cache1 field changedInput schema / properties / source / enumPrevious value: -[
- "workshop",
- "scenario",
- "discussion",
- "issue",
- "all"
-]New value: +[
+ "docs",
+ "discussion",
+ "issue",
+ "all"
+]alg-refresh-cache1 field changedInput schema / properties / force / descriptionPrevious value: -"Force refresh even if cache is recent"New value: +"Discard the cached documentation and re-download it"alg-search-discussions3 fields changedInput schema / properties / limit / maximumAdded value: +50Input schema / properties / limit / minimumAdded value: +1Input schema / properties / limit / typePrevious value: -"number"New value: +"integer"alg-search-docs3 fields changedInput schema / properties / limit / maximumAdded value: +50Input schema / properties / limit / minimumAdded value: +1Input schema / properties / limit / typePrevious value: -"number"New value: +"integer"alg-search-issues3 fields changedInput schema / properties / limit / maximumAdded value: +50Input schema / properties / limit / minimumAdded value: +1Input schema / properties / limit / typePrevious value: -"number"New value: +"integer"alg-semantic-search3 fields changedInput schema / properties / limit / maximumAdded value: +50Input schema / properties / limit / minimumAdded value: +1Input schema / properties / limit / typePrevious value: -"number"New value: +"integer"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
Several tools overlap: alg-search-docs/discussions/issues all search single sources while alg-semantic-search searches across all of them, and the specialist cluster (search/list/get/get-knowledge/ask) has fuzzy boundaries between browsing, fetching, and consulting. The cache trio (refresh/clear/stats) is also easily conflated, though descriptions do provide reasonable guidance.
Nearly all tools use a consistent 'alg-' prefix with a verb_noun pattern (get-workflows, search-docs, list-specialists, clear-cache). A few deviate—alg-semantic-search, alg-graph-visualization, and alg-cache-stats are noun/adjective phrases rather than verb-led—but the overall pattern stays predictable.
17 tools is slightly heavy but justifiable given the server spans documentation search, specialist consultation, caching, and a knowledge graph. The count is on the upper edge of comfortable rather than excessive.
The surface covers search across docs/discussions/issues, specialist discovery and consultation, cache lifecycle, and knowledge-graph construction/visualization. Minor gaps exist (no direct scenario/workshop retrieval beyond knowledge aggregation), but core workflows appear well covered.
Debug, build, and manage Power Automate cloud flows with AI agents
Versioned documentation registry and semantic search for AI tools and coding assistants.
Ask any GitHub repository a question. Get source-backed answers.
Connect Claude.ai, ChatGPT and MCP-compatible coding clients to aictrl engineering workflows. Check account readiness, find and run tasks, inspect workflow progress and approvals, review pull-request findings, and query repository context. Uses OAuth and your aictrl organisation's permissions.
