list_knowledge_bases

Retrieve active or specific knowledge bases from ServiceNow with customizable filters, pagination, and search queries using this integration tool.

Instructions

List knowledge bases from ServiceNow

Input Schema

TableJSON Schema

Name	Required	Description	Default
`params`	Yes

Implementation Reference

src/servicenow_mcp/tools/knowledge_base.py:198-322 (handler)

The handler function that implements the core logic of the 'list_knowledge_bases' tool. It queries the ServiceNow kb_knowledge_base table using the provided parameters, processes the response, and returns a structured list of knowledge bases.

def list_knowledge_bases(
    config: ServerConfig,
    auth_manager: AuthManager,
    params: ListKnowledgeBasesParams,
) -> Dict[str, Any]:
    """
    List knowledge bases with filtering options.

    Args:
        config: Server configuration.
        auth_manager: Authentication manager.
        params: Parameters for listing knowledge bases.

    Returns:
        Dictionary with list of knowledge bases and metadata.
    """
    api_url = f"{config.api_url}/table/kb_knowledge_base"

    # Build query parameters
    query_params = {
        "sysparm_limit": params.limit,
        "sysparm_offset": params.offset,
        "sysparm_display_value": "true",
    }

    # Build query string
    query_parts = []
    if params.active is not None:
        query_parts.append(f"active={str(params.active).lower()}")
    if params.query:
        query_parts.append(f"titleLIKE{params.query}^ORdescriptionLIKE{params.query}")

    if query_parts:
        query_params["sysparm_query"] = "^".join(query_parts)

    # Make request
    try:
        response = requests.get(
            api_url,
            params=query_params,
            headers=auth_manager.get_headers(),
            timeout=config.timeout,
        )
        response.raise_for_status()

        # Get the JSON response 
        json_response = response.json()
        
        # Safely extract the result
        if isinstance(json_response, dict) and "result" in json_response:
            result = json_response.get("result", [])
        else:
            logger.error("Unexpected response format: %s", json_response)
            return {
                "success": False,
                "message": "Unexpected response format",
                "knowledge_bases": [],
                "count": 0,
                "limit": params.limit,
                "offset": params.offset,
            }

        # Transform the results - create a simpler structure
        knowledge_bases = []
        
        # Handle either string or list
        if isinstance(result, list):
            for kb_item in result:
                if not isinstance(kb_item, dict):
                    logger.warning("Skipping non-dictionary KB item: %s", kb_item)
                    continue
                    
                # Safely extract values
                kb_id = kb_item.get("sys_id", "")
                title = kb_item.get("title", "")
                description = kb_item.get("description", "")
                
                # Extract nested values safely
                owner = ""
                if isinstance(kb_item.get("owner"), dict):
                    owner = kb_item["owner"].get("display_value", "")
                
                managers = ""
                if isinstance(kb_item.get("kb_managers"), dict):
                    managers = kb_item["kb_managers"].get("display_value", "")
                
                active = False
                if kb_item.get("active") == "true":
                    active = True
                
                created = kb_item.get("sys_created_on", "")
                updated = kb_item.get("sys_updated_on", "")
                
                knowledge_bases.append({
                    "id": kb_id,
                    "title": title,
                    "description": description,
                    "owner": owner,
                    "managers": managers,
                    "active": active,
                    "created": created,
                    "updated": updated,
                })
        else:
            logger.warning("Result is not a list: %s", result)

        return {
            "success": True,
            "message": f"Found {len(knowledge_bases)} knowledge bases",
            "knowledge_bases": knowledge_bases,
            "count": len(knowledge_bases),
            "limit": params.limit,
            "offset": params.offset,
        }

    except requests.RequestException as e:
        logger.error(f"Failed to list knowledge bases: {e}")
        return {
            "success": False,
            "message": f"Failed to list knowledge bases: {str(e)}",
            "knowledge_bases": [],
            "count": 0,
            "limit": params.limit,
            "offset": params.offset,
        }

src/servicenow_mcp/tools/knowledge_base.py:30-37 (schema)

Pydantic BaseModel defining the input schema/parameters for the list_knowledge_bases tool, including pagination, filtering by active status, and search query.

class ListKnowledgeBasesParams(BaseModel):
    """Parameters for listing knowledge bases."""
    
    limit: int = Field(10, description="Maximum number of knowledge bases to return")
    offset: int = Field(0, description="Offset for pagination")
    active: Optional[bool] = Field(None, description="Filter by active status")
    query: Optional[str] = Field(None, description="Search query for knowledge bases")

src/servicenow_mcp/utils/tool_utils.py:725-731 (registration)
Registration of the 'list_knowledge_bases' tool in the central get_tool_definitions() function, which provides the tool name to handler function, input schema, return type hint, description, and serialization method for the MCP server.
```
"list_knowledge_bases": (
    list_knowledge_bases_tool,
    ListKnowledgeBasesParams,
    Dict[str, Any],  # Expects dict
    "List knowledge bases from ServiceNow",
    "raw_dict",  # Tool returns raw dict
),
```

src/servicenow_mcp/tools/__init__.py:50-60 (registration)

Export/import of the list_knowledge_bases handler function in the tools package __init__.py, making it available for import across the codebase.

from servicenow_mcp.tools.knowledge_base import (
    create_article,
    create_category,
    create_knowledge_base,
    get_article,
    list_articles,
    list_knowledge_bases,
    publish_article,
    update_article,
    list_categories,
)

src/servicenow_mcp/utils/tool_utils.py:174-176 (helper)
Import alias of the handler function as list_knowledge_bases_tool, used in the tool registration.
```
    # list_categories aliased in function call
    list_knowledge_bases as list_knowledge_bases_tool,
)
```

ServiceNow MCP Server