Skip to main content
Glama
clarkemn

cortex-cloud-docs-mcp-server

search_cortex_api_docs

Search Cortex Cloud API documentation to find specific information, endpoints, or usage examples for development needs.

Instructions

Search Cortex Cloud API documentation

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
queryYes

Output Schema

TableJSON Schema
NameRequiredDescriptionDefault
resultYes

Implementation Reference

  • MCP tool handler for 'search_cortex_api_docs'. Registers the tool and implements the logic by calling indexer.search_docs with site='cortex_api' and returning JSON-formatted results.
    @mcp.tool()
    async def search_cortex_api_docs(query: str) -> str:
        """Search Cortex Cloud API documentation"""
        results = await indexer.search_docs(query, site='cortex_api')
        return json.dumps(results, indent=2)
  • MCP tool handler for 'search_cortex_api_docs'. Registers the tool and implements the logic by calling indexer.search_docs with site='cortex_api' and returning JSON-formatted results.
    @mcp.tool()
    async def search_cortex_api_docs(query: str) -> str:
        """Search Cortex Cloud API documentation"""
        results = await indexer.search_docs(query, site='cortex_api')
        return json.dumps(results, indent=2)
  • Core helper method in DocumentationIndexer class that implements the document search logic, including relevance scoring, snippet extraction, and result sorting. This is the primary implementation delegated to by the tool handler.
    async def search_docs(self, query: str, site: str = None) -> List[Dict]:
        """Search indexed documentation"""
        if not self.cached_pages:
            return []
        
        query_lower = query.lower()
        results = []
        
        for url, page in self.cached_pages.items():
            # Filter by site if specified
            if site and page.site != site:
                continue
            
            # Calculate relevance score
            score = 0
            title_lower = page.title.lower()
            content_lower = page.content.lower()
            
            # Higher score for title matches
            if query_lower in title_lower:
                score += 10
                # Even higher for exact title matches
                if query_lower == title_lower:
                    score += 20
            
            # Score for content matches
            content_matches = content_lower.count(query_lower)
            score += content_matches * 2
            
            # Score for partial word matches in title
            query_words = query_lower.split()
            for word in query_words:
                if word in title_lower:
                    score += 5
                if word in content_lower:
                    score += 1
            
            if score > 0:
                # Extract snippet around first match
                snippet = self._extract_snippet(page.content, query, max_length=200)
                
                results.append({
                    'title': page.title,
                    'url': page.url,
                    'site': page.site,
                    'snippet': snippet,
                    'score': score
                })
        
        # Sort by relevance score (highest first) and limit results
        results.sort(key=lambda x: x['score'], reverse=True)
        return results[:10]
  • Dataclass used to cache indexed documentation pages, including expiration logic.
    @dataclass
    class CachedPage:
        title: str
        content: str
        url: str
        site: str
        timestamp: float
        ttl: float = 3600  # 1 hour default TTL
        
        @property
        def is_expired(self) -> bool:
            return time.time() > self.timestamp + self.ttl
Behavior2/5

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

With no annotations provided, the description carries the full burden of behavioral disclosure but offers minimal information. It doesn't describe whether this is a read-only operation, what authentication might be required, how results are returned, or any rate limits. The description only states what the tool does at a high level without operational details.

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 extremely concise at just four words, with zero wasted language. It's front-loaded with the core functionality and uses efficient phrasing. Every word earns its place in communicating the basic purpose.

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?

Given the tool has an output schema (which should document return values) and only one parameter, the description's minimalism is somewhat acceptable. However, with no annotations and 0% schema description coverage, the description should provide more guidance about usage context and parameter expectations to be truly complete for this search functionality.

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

Parameters2/5

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

The schema has 0% description coverage, so the single 'query' parameter is completely undocumented in the schema. The description provides no additional information about what the query parameter should contain, its format, or examples of valid inputs. This leaves significant ambiguity about how to use the tool effectively.

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 verb ('Search') and resource ('Cortex Cloud API documentation'), making the purpose immediately understandable. However, it doesn't differentiate this tool from its siblings like 'search_cortex_docs' or 'search_all_docs', leaving ambiguity about scope boundaries.

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?

No guidance is provided about when to use this tool versus alternatives like 'search_cortex_docs' or 'search_all_docs'. The description offers no context about appropriate use cases, prerequisites, or exclusions, leaving the agent to guess based on tool names alone.

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/clarkemn/cortex-cloud-docs-mcp-server'

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