Skip to main content
Glama
AgentWong
by AgentWong

add_ansible_collection

Store Ansible collections with version and documentation details in the IaC memory system for tracking and reference.

Instructions

Add a new Ansible collection to the memory store with version and documentation information

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
nameYesCollection name
versionYesCollection version
source_urlYesSource repository URL
doc_urlYesDocumentation URL

Implementation Reference

  • MCP tool handler function that validates arguments, calls the DB helper, and returns success/error messages.
    async def handle_add_ansible_collection(db: Any, arguments: Dict[str, Any], operation_id: str) -> list[types.TextContent | types.ImageContent | types.EmbeddedResource]:
        """Handle add_ansible_collection tool."""
        # Validate required arguments
        required_args = ["name", "version", "source_url", "doc_url"]
        missing_args = [arg for arg in required_args if arg not in arguments]
        if missing_args:
            error_msg = f"Missing required arguments for add_ansible_collection: {', '.join(missing_args)}"
            logger.error(error_msg, extra={"operation_id": operation_id})
            return [TextContent(type="text", text=error_msg)]
    
        try:
            logger.info(
                "Adding Ansible collection",
                extra={
                    "collection_name": arguments["name"],
                    "version": arguments["version"],
                    "operation_id": operation_id,
                },
            )
    
            # Add collection
            collection_id = add_ansible_collection(
                db,
                arguments["name"],
                arguments["version"],
                arguments["source_url"],
                arguments["doc_url"],
            )
    
            return [TextContent(
                type="text",
                text=f"Added collection {arguments['name']} with ID: {collection_id}"
            )]
    
        except Exception as e:
            error_msg = f"Failed to add collection: {str(e)}"
            logger.error(error_msg, extra={"operation_id": operation_id})
            raise McpError(
                types.ErrorData(
                    code=types.INTERNAL_ERROR,
                    message=error_msg,
                    data={
                        "tool": "add_ansible_collection",
                        "operation_id": operation_id,
                    },
                )
            )
  • Database helper function that performs the actual INSERT into ansible_collections table.
    def add_ansible_collection(
        db: DatabaseManager, name: str, version: str, source_url: str, doc_url: str
    ) -> str:
        """Add a new Ansible collection."""
        try:
            with db.get_connection() as conn:
                # Set busy timeout before any operations
                conn.execute(
                    "PRAGMA busy_timeout = 5000"
                )  # 5 second timeout per testing rules
                conn.execute("BEGIN IMMEDIATE")  # Start transaction
                try:
                    cursor = conn.execute(
                        """INSERT INTO ansible_collections
                        (name, version, source_url, doc_url)
                        VALUES (?, ?, ?, ?)""",
                        (name, version, source_url, doc_url),
                    )
                    collection_id = str(cursor.lastrowid)
                    conn.commit()
                    return collection_id
                except Exception:
                    conn.rollback()
                    raise
        except sqlite3.Error as e:
            raise DatabaseError(
                f"Failed to add Ansible collection: {str(e)}. Operation timed out after 5 seconds."
            )
  • JSON schema definition for the tool's input parameters used for validation.
    "add_ansible_collection": {
        "type": "object",
        "description": "Add a new Ansible collection to the memory store with version and documentation information",
        "required": ["name", "version", "source_url", "doc_url"],
        "properties": {
            "name": {"type": "string", "description": "Collection name"},
            "version": {"type": "string", "description": "Collection version"},
            "source_url": {"type": "string", "description": "Source repository URL"},
            "doc_url": {"type": "string", "description": "Documentation URL"},
        },
    },
  • Registration of the tool handler in the ansible_tool_handlers dictionary, used for MCP tool dispatching.
    ansible_tool_handlers = {
        "get_ansible_collection_info": handle_get_ansible_collection_info,
        "list_ansible_collections": handle_list_ansible_collections,
        "get_collection_version_history": handle_get_collection_version_history,
        "get_ansible_module_info": handle_get_ansible_module_info,
        "list_collection_modules": handle_list_collection_modules,
        "get_module_version_compatibility": handle_get_module_version_compatibility,
        "add_ansible_collection": handle_add_ansible_collection,
        "add_ansible_module": handle_add_ansible_module,
    }
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full burden for behavioral disclosure. While it indicates this is a write operation ('Add'), it doesn't specify whether this requires authentication, what happens if a collection already exists (overwrites? errors?), whether the operation is idempotent, or what the memory store's persistence characteristics are. For a mutation tool with zero annotation coverage, this is insufficient behavioral context.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, well-constructed sentence that efficiently communicates the core functionality. Every word earns its place: 'Add' (action), 'new Ansible collection' (resource), 'to the memory store' (destination), 'with version and documentation information' (scope). No wasted words or redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a 4-parameter mutation tool with no annotations and no output schema, the description is minimally adequate but leaves significant gaps. It covers the basic purpose but lacks behavioral context (permissions, error conditions, idempotency) and doesn't explain what happens after the operation (what does 'added to memory store' mean practically?). The absence of output schema means the description should ideally hint at return values, which it doesn't.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The description mentions 'version and documentation information' which aligns with some parameters, but with 100% schema description coverage, all parameters are already documented in the schema. The description doesn't add meaningful semantic context beyond what's in the schema descriptions, such as format expectations for URLs or version strings. Baseline 3 is appropriate when the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Add'), resource ('Ansible collection'), and destination ('to the memory store') with additional context about what information is included ('version and documentation information'). It distinguishes from siblings like 'add_ansible_module' by specifying the collection type, but doesn't explicitly contrast with other collection-related tools like 'update_collection_version' or 'get_ansible_collection_info'.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

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. With siblings like 'update_collection_version', 'get_ansible_collection_info', and 'list_ansible_collections', there's no indication whether this is for initial creation versus updates, or how it relates to retrieval operations. The description only states what it does, not when it should be used.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/AgentWong/iac-memory-mcp-server-project'

If you have feedback or need assistance with the MCP directory API, please join our Discord server