Skip to main content
Glama

Ansible Know MCP Server

The Ansible knowledge engine for AI agents — discover collections, understand modules, and generate reusable skills via MCP.

A community proof of concept built with spec-driven AI-assisted development.

┌──────────────────────────────────────────────────────────────────────┐
│  >_  ansible-know-mcp                                          [x]  │
├──────────────────────────────────────────────────────────────────────┤
│                                                                      │
│  > I need to create an AWS EC2 instance with Ansible                 │
│                                                                      │
│    Let me find the right collection and module.                      │
│                                                                      │
│      * search_collections("aws ec2")                                 │
│        amazon.aws                          12.3M downloads           │
│                                                                      │
│      * get_module_doc("amazon.aws.ec2_instance")                     │
│        name, image_id, instance_type, state, key_name, tags...       │
│                                                                      │
│      → generate_skill("amazon.aws.ec2_instance")                     │
│        Loaded skill: ec2_instance (12 params, 3 examples)            │
│                                                                      │
│    I have everything I need. Instance type, AMI, and name?           │
│                                                                      │
├──────────────────────────────────────────────────────────────────────┤
│  > t3.micro, Fedora Linux 44, web-server █                           │
└──────────────────────────────────────────────────────────────────────┘

              DISCOVER ──→ LEARN ──→ SKILL ──→ BUILD

What It Does

Ansible Know is the learn layer for AI agents working with Ansible:

  • Galaxy collection discovery — search 2000+ collections by keyword, ranked by download count

  • Multi-server Galaxy support — query public Galaxy, private Automation Hub, and AAP Gateway in parallel

  • Module, role, and plugin documentation — structured parameter specs, examples, and metadata with Galaxy fallback

  • Documentation search — find conceptual guides from Ansible's AI-friendly docs, fetch full pages as Markdown

  • Collection management — auto-install collections and get collection-level overviews

  • Skill generation — create ready-to-use skill packages that teach agents how to use specific modules, roles, and plugins

  • Resources and prompts — browse skills, doc sources, and Galaxy servers; pre-built templates for playbook review, module explanation, and role generation

Together with Ansible Devtools MCP (create + test) and AAP MCP (deploy), this enables the full autonomous cycle: learn -> create -> test -> deploy.

 Agent's MCP servers:

 +----------------------------+  +--------------------------+  +--------------+
 | Ansible Know               |  | Ansible Devtools         |  | AAP MCP      |
 | (this project)             |  |                          |  |              |
 |                            |  | CREATE                   |  |              |
 | search_collections         |  | ansible_create_*         |  | controller.* |
 | search_modules             |  | build_ee                 |  | eda.*        |
 | search_plugins             |  | setup_environment        |  | gateway.*    |
 | get_module_doc             |  | environment_info         |  | galaxy.*     |
 | get_plugin_doc             |  |                          |  |              |
 | get_role_doc               |  | TEST                     |  |              |
 | search_standalone_roles    |  |                          |  |              |
 | get_standalone_role_doc    |  |                          |  |              |
 | get_collection_docs        |  | ansible_lint             |  |              |
 | get_collection_manifest    |  | ansible_navigator        |  |              |
 | search_docs                |  |                          |  |              |
 | fetch_doc                  |  | REFERENCE                |  |              |
 | ensure_collection          |  | zen_of_ansible           |  |              |
 | generate_skill             |  |                          |  |              |
 | generate_role_skill        |  |                          |  |              |
 | generate_plugin_skill      |  |                          |  |              |
 | generate_collection_skills |  |                          |  |              |
 | list_skills / get_skill    |  |                          |  |              |
 | package_as_plugin          |  |                          |  |              |
 | package_for_lola           |  |                          |  |              |
 | clear_cache                |  |                          |  |              |
 |                            |  |                          |  |              |
 | LEARN                      |  | CREATE + TEST            |  | DEPLOY       |
 +----------------------------+  +--------------------------+  +--------------+

Related MCP server: mcp-skills

Installation

Using uvx (recommended):

uvx ansible-know-mcp

Using pip:

pip install ansible-know-mcp

Requirement: ansible-core must be installed in the same Python environment (provides ansible-doc).

Usage

Claude Code

# Project-scoped
claude mcp add ansible-know -- uvx ansible-know-mcp

# Available in all projects
claude mcp add --scope user ansible-know -- uvx ansible-know-mcp

VS Code / Cursor

Add to .vscode/mcp.json in your workspace:

{
  "servers": {
    "ansible-know": {
      "command": "uvx",
      "args": ["ansible-know-mcp"],
      "type": "stdio",
      "env": {
        "ANSIBLE_KNOW_PROJECT_DIR": "${workspaceFolder}"
      }
    }
  }
}

Skill packages default to {project}/skills/. Claude Code injects CLAUDE_PROJECT_DIR automatically; set ANSIBLE_KNOW_PROJECT_DIR for other clients. After generate_collection_skills, a managed section in AGENTS.md points host agents at that tree.

Pairing with Ansible Devtools MCP (next-mcp)

know-mcp and next-mcp use different env vars. To share one skills directory, also configure next-mcp's local skill source (extension setting ansibleEnvironments.skillSources, or ANSIBLE_SKILL_SOURCES):

{
  "ansibleEnvironments.skillSources": [
    {
      "id": "know-generated",
      "type": "local",
      "url": "${workspaceFolder}/skills",
      "trust": "community"
    }
  ]
}

Use {id, type, url, trust} — next-mcp's loader expects url (directory path), not path/repo alone. Until next-mcp expands local scan depth past one level, skill_* tools see collection-level SKILL.md files; nested module skills remain available to host agents via the AGENTS.md pointer. See docs/superpowers/specs/2026-08-02-skill-discoverability-alignment.md.

Any MCP client

The server communicates over stdio by default:

uvx ansible-know-mcp

HTTP Transport

Run as a standalone HTTP server for shared/remote access:

# HTTP on default port (8080)
ansible-know-mcp --transport http

# Custom host and port
ansible-know-mcp --transport http --host 10.0.0.1 --port 9090

# Via environment variables (useful for containers)
export ANSIBLE_KNOW_TRANSPORT=http
export ANSIBLE_KNOW_PORT=8080
ansible-know-mcp

Connect from any MCP client using the streamable HTTP URL: http://<host>:8080/mcp

Security: HTTP mode has no built-in authentication. Deploy behind a reverse proxy with authentication/authorization, or use only on trusted networks.

Docker

Build and run from source:

docker build -t ansible-know-mcp .
docker run -p 7860:7860 ansible-know-mcp

Connect from any MCP client using the streamable HTTP URL: http://localhost:7860/mcp

Remote MCP (Hugging Face Spaces)

A public instance is available as a remote MCP server:

Claude Code:

claude mcp add ansible-know --transport http https://know.ansible.ar/mcp

VS Code / Cursor (.vscode/mcp.json):

{
  "servers": {
    "ansible-know": {
      "type": "http",
      "url": "https://know.ansible.ar/mcp"
    }
  }
}

Full stack

{
  "mcpServers": {
    "ansible-know":     { "command": "uvx", "args": ["ansible-know-mcp"] },
    "ansible-devtools": { "command": "ade", "args": ["mcp"] },
    "aap":              { "command": "aap-mcp-server" }
  }
}

Tools

Discovery

Tool

Description

search_collections(query, tags?)

Search Ansible Galaxy for collections by keyword, ranked by download count

search_modules(keyword, namespace?)

Find modules by keyword in name or description (up to 50 matches)

search_plugins(keyword, namespace?, plugin_type?)

Find plugins by keyword (lookup, filter, inventory, callback, etc.)

get_module_doc(module_name)

Full structured docs: params, examples, API detection. Falls back to Galaxy if not installed locally

get_plugin_doc(plugin_name, plugin_type)

Full structured plugin documentation with Galaxy fallback

get_role_doc(role_name)

Role documentation with three-tier resolution: local ansible-doc, Galaxy README, or graceful degradation

search_standalone_roles(query, tags?)

Search Galaxy standalone (legacy v1) roles by keyword

get_standalone_role_doc(role_name)

Structured docs for a 2-part namespace.role from Galaxy README HTML

get_collection_docs(collection_namespace, version?)

Get all module docs for a collection from Galaxy in a single call

get_collection_manifest(collection_namespace)

Collection-level manifest with per-module and per-role summaries

search_docs(query, source?, topic?, audience?, core_only?)

Search documentation manifests for conceptual guides (up to 20 matches). Use source="cop-good-practices" for CoP good practices / "best practices" questions.

fetch_doc(url, max_tokens?)

Fetch a docs.ansible.com, docs.redhat.com, or CoP raw GitHub README.adoc URL (from search_docs) as clean Markdown

search_docs source= routing:

Need

source=

Official HOWTO (playbooks, vault, inventory syntax)

ansible-core (or omit)

ansible-lint rules / profiles

ansible-lint

Navigator / builder / creator / molecule

matching source name

AAP product manuals

aap-2.5 / aap-2.6 / aap-2.7

CoP opinionated practices (role design, naming, CaC, Git; users often say best practices)

cop-good-practices (not cop-best-practices)

Unsure which corpus

omit source (CoP may be missing; retry with cop-good-practices)

Published CoP site (citation only, not a fetch_doc URL): https://redhat-cop.github.io/automation-good-practices/

Collection management

Tool

Description

ensure_collection(collection_namespace, version?)

Install a collection to a temporary directory for this session

Skills

Tool

Description

list_skills()

List all generated skills

get_skill(skill_name)

Read a skill's SKILL.md content

generate_skill(module_name, install_to?)

Generate a skill package for one module

generate_role_skill(role_name, install_to?)

Generate a skill package for one role

generate_plugin_skill(plugin_name, plugin_type, install_to?)

Generate a skill package for one plugin

generate_collection_skills(collection_namespace, install_to?)

Batch generate skills for an entire collection

package_as_plugin(collection, output_dir, source_dir?, plugin_name?, include_mcp_config?, write_plugin_json?, write_tarball?, mcp_transport?, mcp_url?)

Wrap generated skills into an Agent Plugins directory (plugin.json + flat skills/ + optional mcp.json + .tar.gz; stdio or streamable-http; does not change generate_* layout)

package_for_lola(collection, output_dir, source_dir?, module_name?, write_market_yml?)

Deprecated — prefer package_as_plugin. Wrap generated skills into a Lola module directory

Maintenance

Tool

Description

clear_cache(scope?)

Clear Galaxy and/or doc manifest caches

Resources

URI

Description

skills://list

List all generated skill packages

skills://{skill_name}

Read a skill's SKILL.md content by FQCN

galaxy://installed

List collections installed in this session

galaxy://servers

List configured Galaxy servers (names, URLs, auth types — never credentials)

server://version

Installed and latest version info with upgrade status

docs://sources

List configured documentation manifest sources

Prompts

Prompt

Description

review_playbook(playbook_yaml)

Review a playbook against module docs and best practices

explain_module(module_name)

Detailed module explanation with usage examples

explain_plugin(plugin_name, plugin_type)

Detailed plugin explanation with usage examples

generate_role(role_purpose, modules)

Generate a role skeleton using specified modules

find_collection(platform_or_use_case)

Guide through search, install, and explore workflow

Multi-server Galaxy Support

Ansible Know reads [galaxy_server.*] sections from ansible.cfg (resolved in standard order: ANSIBLE_CONFIG env, ./ansible.cfg, ~/.ansible.cfg, /etc/ansible/ansible.cfg):

# ansible.cfg
[galaxy_server.automation_hub]
url = https://hub.example.com/api/galaxy/
token = my-token

[galaxy_server.public_galaxy]
url = https://galaxy.ansible.com/api/
  • Token auth, basic auth, and per-server TLS verification

  • search_collections queries all configured servers in parallel, merging results with source attribution

  • get_module_doc / get_role_doc Galaxy fallback tries servers in priority order

  • Public Galaxy is appended as a final fallback; opt out with ANSIBLE_KNOW_NO_PUBLIC_GALAXY=1

  • Per-server env var overrides: ANSIBLE_GALAXY_SERVER_{NAME}_{KEY} (matches ansible-core behavior)

  • View configured servers via the galaxy://servers resource

Configuration

Environment Variable

Description

Default

ANSIBLE_KNOW_SKILLS_DIR

Explicit skills directory for writes / single-path reads (wins over project-dir chain)

(not set)

ANSIBLE_KNOW_SKILLS_PATH

Colon-separated skills dirs for list_skills / get_skill / skills://* (like $PATH; first match wins). When set, replaces the single-dir search. Include the write directory (project skills/ or ANSIBLE_KNOW_SKILLS_DIR) in this list if generated skills should remain discoverable

(not set)

ANSIBLE_KNOW_PROJECT_DIR

Project root; skills go to {root}/skills

(not set)

CLAUDE_PROJECT_DIR

Same as project dir when set by Claude Code

(not set)

(skills fallback)

If none of the above are set

cwd/skills/

ANSIBLE_KNOW_DOC_SOURCES

JSON dict of doc manifest sources

Built-in ansible-core source

ANSIBLE_KNOW_GALAXY_URL

Galaxy API base URL

https://galaxy.ansible.com

ANSIBLE_KNOW_SKIP_UPDATE_CHECK

Set to 1 to disable PyPI version check at startup

(not set)

ANSIBLE_KNOW_NO_PUBLIC_GALAXY

Set to 1 to suppress auto-appending public Galaxy

(not set)

Upgrading

Method

Command

uvx

uvx --upgrade ansible-know-mcp

pip

pip install --upgrade ansible-know-mcp

Claude Code

uvx --upgrade ansible-know-mcp then restart Claude Code

VS Code / Cursor

uvx --upgrade ansible-know-mcp then reload window

Local dev

git pull && uv sync

Note: uvx caches the installed version and does not auto-upgrade on new releases. To always run the latest version (at the cost of slower startup): claude mcp add ansible-know -- uvx --upgrade ansible-know-mcp

Deployment

Hugging Face Spaces

Deploy as a remote MCP server on Hugging Face Spaces:

  1. Create a new Space with SDK: Docker

  2. The Space's README.md must include YAML frontmatter:

    ---
    title: Ansible Know MCP
    emoji: "\U0001F4DA"
    sdk: docker
    app_port: 7860
    ---
  3. Push this repository (or set it as the Space's linked repo)

  4. The included Dockerfile builds and starts the server automatically

Note: Free-tier Spaces sleep after inactivity. MCP clients will see connection errors until the Space wakes up (~30-60s cold start). Use a paid Space or a keep-alive ping for production use.

Custom domain (optional):

  1. In the Space settings, go to Custom domains

  2. Add your domain (e.g., know.ansible.ar)

  3. Create a CNAME record pointing to <owner>-<space-name>.hf.space

  4. HF provisions a TLS certificate automatically

Environment variables (set in Space settings):

Variable

Required

Description

ANSIBLE_KNOW_SKILLS_DIR

No

Defaults to ./skills/ (ephemeral in container)

ANSIBLE_KNOW_NO_PUBLIC_GALAXY

No

Set to 1 to disable public Galaxy fallback

Generic Docker

The Dockerfile works with any container platform (Fly.io, Railway, Cloud Run, etc.):

docker build -t ansible-know-mcp .
docker run -p 8080:7860 ansible-know-mcp

Override defaults with environment variables:

docker run -p 9090:9090 \
  -e ANSIBLE_KNOW_PORT=9090 \
  ansible-know-mcp

Contributing

See CONTRIBUTING.md for development setup, testing, architecture guidelines, and how to add new MCP tools.

Acknowledgments

The skill generation approach in this project was inspired by AnsibleClaw by Michael Tao — a skill generation framework that converts Ansible modules into portable AI agent skill packages.

License

GPL-3.0-or-later

Available Tools

22 tools
clear_cacheClear CacheA
Idempotent

Clear server caches.

Clears Galaxy version/docs-blob caches, standalone-role v1 caches, doc manifest/page caches, or both. Useful when cached data becomes stale during long-running sessions.

Inputs: scope. Returns: result

ensure_collectionEnsure CollectionA
Idempotent

Install a collection to a temporary directory for this session.

Installs once and pins the resolved version. Subsequent calls with the same namespace skip unless a different version is explicitly requested. If a different version is requested than currently installed, the collection will be reinstalled.

Returns dict with keys:

  • namespace: str — the collection namespace

  • version: str — the installed/active version (always set)

  • status: 'installed' (freshly installed or upgraded) or 'already_installed' (same version already present, no action taken)

  • message: str — human-readable summary including the active version

  • handle: str — opaque session handle; pass it as collection_handle to subsequent tool calls on remote connections On failure returns {"error": str}.

Pass collection_handle when re-invoking ensure_collection on a remote connection with a handle obtained from a prior call (e.g. to install an additional collection into the same session). Omit it on local stdio, or on remote when you want a brand-new session handle minted.

Inputs: collection_namespace (required), version, collection_handle. Returns: result

fetch_docFetch DocA
Read-only

Fetch a docs page as clean Markdown.

Returns documentation content ready for LLM consumption. Use search_docs to discover relevant page URLs. Accepts docs.ansible.com, docs.redhat.com, or CoP good-practices raw GitHub README.adoc URLs from search_docs hits (not arbitrary raw.githubusercontent.com hosts).

Inputs: url (required), max_tokens. Returns: result

generate_collection_skillsGenerate Collection SkillsA
Idempotent

Batch generate skills for an entire collection.

Generates/updates the collection MANIFEST.json as a byproduct. Updates AGENTS.md in the project root with a managed section listing available collections for cross-agent discovery. Returns {"succeeded": int, "failed": int, "total": int, "manifest": dict, "collection_skill": str}, or {"error": str} on failure.

Module/plugin docs use batched ansible-doc calls. Names missing from a batch (or a hard batch failure) are counted in failed; partial batch success still writes skills for resolved names.

Inputs: collection_namespace (required), install_to, collection_handle. Returns: result

generate_plugin_skillGenerate Plugin SkillA
Idempotent

Generate a skill package for one plugin.

Writes SKILL.md to disk (no scripts/ or assets/). Returns the SKILL.md content as str, or {"error": str} on failure.

Inputs: plugin_name (required), plugin_type (required), install_to, collection_handle. Returns: result

generate_role_skillGenerate Role SkillA
Idempotent

Generate a skill package for one role.

Writes SKILL.md + assets/playbook.yml to disk (no scripts/). Returns the SKILL.md content as str, or {"error": str} on failure.

Inputs: role_name (required), install_to, collection_handle. Returns: result

generate_skillGenerate SkillA
Idempotent

Generate a skill package for one module.

Writes SKILL.md + scripts + playbook to disk. Returns the SKILL.md content as str, or {"error": str} on failure.

Inputs: module_name (required), install_to, collection_handle. Returns: result

get_collection_docsGet Collection DocsA
Read-only

Get full parameter-level documentation for every module in a collection from Galaxy.

WARNING: output can be very large (100 KB+) for collections with many modules. Use get_collection_manifest first for a compact overview, then get_module_doc for the specific modules you need. Reserve this tool for batch operations that genuinely need all parameter details at once (e.g. skill generation).

Returns all module docs in a single API call without installing the collection. Result shape: {"modules": {fqcn: {module_name, short_description, params, examples, is_api_module}, ...}, "doc_source": "galaxy", "doc_version": str}. On failure returns {"error": str}.

Inputs: collection_namespace (required), version, collection_handle. Returns: result

get_collection_manifestGet Collection ManifestA
Read-only

Get a lightweight collection overview: module/role/plugin names with one-line descriptions.

Prefer this over get_collection_docs when exploring a collection — it returns a compact summary suitable for deciding which modules to drill into with get_module_doc.

Returns cached MANIFEST.json if available, otherwise generates on-demand (metadata extraction only, no skill generation). On failure returns {"error": str}.

Module docs are fetched in batched ansible-doc calls. If the entire batch fails hard, the manifest is written with zero module entries (roles/plugins from list discovery are still included when present).

Inputs: collection_namespace (required), collection_handle. Returns: result

get_module_docGet Module DocA
Read-only

Get full structured documentation for one module.

Returns: module_name, short_description, params (list with name/type/required/default/choices/description/aliases), examples (raw YAML), is_api_module, doc_source ('local' or 'galaxy'). When doc_source is 'galaxy', also includes doc_version and optionally doc_warning. Falls back to Galaxy if collection is not installed locally. On failure returns {"error": str}.

Inputs: module_name (required), collection_handle. Returns: result

get_plugin_docGet Plugin DocA
Read-only

Get full structured documentation for one plugin.

Returns: plugin_name, plugin_type, short_description, params, examples, doc_source ('local' or 'galaxy'). Falls back to Galaxy if collection is not installed locally. On failure returns {"error": str}.

Inputs: plugin_name (required), plugin_type (required), collection_handle. Returns: result

get_role_docGet Role DocA
Read-only

Get full structured documentation for one role.

Returns: role_name, content_type ('role'), short_description, doc_source ('local', 'galaxy_readme', or 'unavailable'), entry_points (dict of entry point names to {description, options}), dependencies (list), examples (str). When doc_source is 'galaxy_readme', also includes doc_version and doc_warning. Falls back to Galaxy README parsing if local ansible-doc returns empty. On validation failure returns {"error": str}.

Inputs: role_name (required), collection_handle. Returns: result

get_skillGet SkillA
Read-only

Read a specific skill's SKILL.md content by name.

Searches ANSIBLE_KNOW_SKILLS_PATH (colon-separated) when set, otherwise the single SKILLS_DIR. First match wins.

Returns: SKILL.md content as str, or {"error": str} on failure/not found.

Inputs: skill_name (required). Returns: result

get_standalone_role_docGet Standalone Role DocA
Read-only

Get standalone role documentation for a 2-part namespace.role identifier.

Use this for standalone roles discovered with search_standalone_roles. This tool does not replace get_role_doc for collection roles.

Inputs: role_name (required). Returns: result

list_skillsList SkillsB
Read-only

List all available generated skills. Returns name, description, path for each.

Searches ANSIBLE_KNOW_SKILLS_PATH (colon-separated) when set, otherwise the single SKILLS_DIR. Duplicate names keep the first path's entry.

Returns: [{"name": str, "description": str, "path": str}, ...] or {"error": str} on failure.

Inputs: collection. Returns: result

package_as_pluginPackage As PluginA
DestructiveIdempotent

Wrap already-generated skills into an Agent Plugins directory.

Does not change generate_* output layout. Copies skills/{collection-kebab}/{skill}/ into {output_dir}/{plugin}/skills/{skill}/ and writes plugin.json (and optionally mcp.json + .tar.gz) per the Agent Plugins specification. Replaces any existing skills/ tree under the target plugin directory (destructive but idempotent).

Returns: {"collection", "plugin_name", "plugin_dir", "skill_count", "skills", "plugin_json", "mcp_json", "archive"} or {"error": str} on failure.

Inputs: collection (required), output_dir (required), mcp_url, source_dir, +5 more. Returns: result

package_for_lolaPackage For LolaA
DestructiveIdempotent

Wrap already-generated skills into a Lola-compatible module directory.

.. deprecated:: Prefer :func:package_as_plugin (Agent Plugins). Kept for one release cycle for backward compatibility.

Does not change generate_* output layout. Copies skills/{collection-kebab}/{skill}/ into {output_dir}/{module}/skills/{skill}/ for marketplace / lola mod add use. Replaces any existing skills/ tree under the target module directory (destructive but idempotent).

Returns: {"collection", "module_name", "module_dir", "skill_count", "skills", "market_yml"} or {"error": str} on failure.

Inputs: collection (required), output_dir (required), source_dir, module_name, +1 more. Returns: result

search_collectionsSearch CollectionsA
Read-only

Search Ansible Galaxy for collections by keyword.

Returns non-deprecated collections ranked by download count. Use this to discover which collection provides modules for a specific platform or use case.

After finding a collection, use ensure_collection() to install it, then get_module_doc() or get_collection_manifest() to explore its modules.

Returns: {"query": str, "count": int, "collections": [{"namespace": str, "description": str, "tags": [str], "latest_version": str, "module_count": int, "download_count": int, "deprecated": bool, "signed": bool}, ...]} On failure returns {"error": str}.

Inputs: query (required), tags. Returns: result

search_docsSearch DocsA
Read-only

Search documentation manifests for conceptual guides.

Returns up to 20 matching entries with title, summary, topic, audience, lines, source, and raw URL. On failure returns {"error": str}.

Choose source by corpus:

  • ansible-core (or omit): official HOWTO — playbooks, vault, inventory syntax

  • ansible-lint: rules and profiles

  • ansible-navigator / ansible-builder / ansible-creator / molecule: matching source

  • aap-2.5 / aap-2.6 / aap-2.7: AAP product manuals

  • cop-good-practices: CoP opinionated practices (role design, naming, CaC, Git, testing process). Users often say "best practices"; do not invent cop-best-practices. Unfiltered search fills the 20-hit window with official + AAP first; CoP may be absent — retry with source='cop-good-practices' for CoP-shaped questions.

Inputs: query (required), topic, source, audience, +1 more. Returns: result

search_modulesSearch ModulesB
Read-only

Find Ansible modules by keyword in name or description. Returns up to 50 matches as {fqcn: short_description}.

Returns: {"module.fqcn": "short description", ...} or {"error": str} on failure.

Inputs: keyword (required), namespace, collection_handle. Returns: result

search_pluginsSearch PluginsB
Read-only

Find Ansible plugins by keyword. Returns up to 50 matches as {fqcn: short_description}.

Plugin types: lookup, filter, test, connection, become, strategy, callback, inventory, cache, cliconf, httpapi, netconf, shell, vars. On failure returns {"error": str}.

Inputs: keyword (required), namespace, plugin_type, collection_handle. Returns: result

search_standalone_rolesSearch Standalone RolesA
Read-only

Search Galaxy standalone/legacy roles by keyword.

This targets standalone (2-part) roles. Collection roles use search_collections/get_role_doc. tags accepts a single Galaxy tag; if comma-separated values are provided, only the first segment is sent.

If public Galaxy is disabled and no configured server supports v1 role endpoints, expect a v1-unsupported error.

Inputs: query (required), tags. Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.7/5.0

    Scored across 22 tools

    Disambiguation4/5

    Most tools target clearly distinct resources (modules vs plugins vs collections vs roles vs skills). The main overlaps are the get_role_doc vs get_standalone_role_doc pair, get_collection_manifest vs get_collection_docs, and the deprecated package_for_lola duplicating package_as_plugin — but descriptions explicitly disambiguate each of these.

    Naming Consistency4/5

    Strong snake_case verb_noun pattern throughout (search_modules, get_module_doc, generate_skill, clear_cache). Minor deviations: fetch_doc vs get_*_doc for retrieval, and generate_skill (module-specific) sitting awkwardly beside generate_role_skill/generate_plugin_skill.

    Tool Count3/5

    22 tools is on the heavy side and includes a deprecated tool (package_for_lola) that will soon be dead weight. The domain is genuinely broad (search, docs, install, skill generation, packaging, cache), so most tools earn a place, but the surface feels large.

    Completeness4/5

    Covers discovery, documentation retrieval, collection installation, skill generation, packaging, and cache management — a full lifecycle for its stated purpose. Minor gaps like skill deletion/removal or list_collection_skills exist but are not blocking.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      B
      quality
      D
      maintenance
      A Model Context Protocol server that enables AI agents to access, search, and understand structured package documentation and source code from Git repositories. It automatically generates specialized tools to browse module overviews, components, and detailed documentation for technical libraries.
      1
      57 npm
      8
      MIT
    • A
      license
      A
      quality
      D
      maintenance
      Integrates with the skills.sh ecosystem to allow AI coding agents to discover, install, and manage reusable instruction sets. It enables autonomous agents to extend their capabilities with structured skill discovery and full lifecycle management through the Model Context Protocol.
      6
      13 npm
      1
      Apache 2.0
    • A
      license
      A
      quality
      C
      maintenance
      Combines semantic search with AST-based code exploration for AI agents, enabling natural language code search, file structure browsing, symbol inspection, and dependency analysis through the Model Context Protocol.
      30
      4
      MIT