Skip to main content
Glama
simonl77

Salesforce MCP Server

by simonl77

salesforce_search_objects

Search Salesforce standard and custom objects by name pattern to quickly locate specific data structures within your Salesforce instance.

Instructions

Search for Salesforce standard and custom objects by name pattern. Examples: 'Account' will find Account, AccountHistory; 'Order' will find WorkOrder, ServiceOrder__c etc.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
searchPatternYesSearch pattern to find objects (e.g., 'Account Coverage' will find objects like 'AccountCoverage__c')

Implementation Reference

  • The handler function that executes the salesforce_search_objects tool. It uses conn.describeGlobal() to get all objects, filters them based on the searchPattern by splitting into terms and checking name/label, formats results.
    export async function handleSearchObjects(conn: any, searchPattern: string) {
      // Get list of all objects
      const describeGlobal = await conn.describeGlobal();
      
      // Process search pattern to create a more flexible search
      const searchTerms = searchPattern.toLowerCase().split(' ').filter(term => term.length > 0);
      
      // Filter objects based on search pattern
      const matchingObjects = describeGlobal.sobjects.filter((obj: SalesforceObject) => {
        const objectName = obj.name.toLowerCase();
        const objectLabel = obj.label.toLowerCase();
        
        // Check if all search terms are present in either the API name or label
        return searchTerms.every(term => 
          objectName.includes(term) || objectLabel.includes(term)
        );
      });
    
      if (matchingObjects.length === 0) {
        return {
          content: [{
            type: "text",
            text: `No Salesforce objects found matching "${searchPattern}".`
          }],
          isError: false,
        };
      }
    
      // Format the output
      const formattedResults = matchingObjects.map((obj: SalesforceObject) => 
        `${obj.name}${obj.custom ? ' (Custom)' : ''}\n  Label: ${obj.label}`
      ).join('\n\n');
    
      return {
        content: [{
          type: "text",
          text: `Found ${matchingObjects.length} matching objects:\n\n${formattedResults}`
        }],
        isError: false,
      };
    }
  • The Tool object defining the schema for salesforce_search_objects, including name, description, and inputSchema with searchPattern parameter.
    export const SEARCH_OBJECTS: Tool = {
      name: "salesforce_search_objects",
      description: "Search for Salesforce standard and custom objects by name pattern. Examples: 'Account' will find Account, AccountHistory; 'Order' will find WorkOrder, ServiceOrder__c etc.",
      inputSchema: {
        type: "object",
        properties: {
          searchPattern: {
            type: "string",
            description: "Search pattern to find objects (e.g., 'Account Coverage' will find objects like 'AccountCoverage__c')"
          }
        },
        required: ["searchPattern"]
      }
    };
  • src/index.ts:73-77 (registration)
    Registration in the CallToolRequestSchema handler switch statement that extracts searchPattern from args and calls handleSearchObjects.
    case "salesforce_search_objects": {
      const { searchPattern } = args as { searchPattern: string };
      if (!searchPattern) throw new Error('searchPattern is required');
      return await handleSearchObjects(conn, searchPattern);
    }
  • src/index.ts:45-63 (registration)
    Registration in ListToolsRequestSchema handler that includes SEARCH_OBJECTS in the list of available tools.
    server.setRequestHandler(ListToolsRequestSchema, async () => ({
      tools: [
        SEARCH_OBJECTS, 
        DESCRIBE_OBJECT, 
        QUERY_RECORDS, 
        AGGREGATE_QUERY,
        DML_RECORDS,
        MANAGE_OBJECT,
        MANAGE_FIELD,
        MANAGE_FIELD_PERMISSIONS,
        SEARCH_ALL,
        READ_APEX,
        WRITE_APEX,
        READ_APEX_TRIGGER,
        WRITE_APEX_TRIGGER,
        EXECUTE_ANONYMOUS,
        MANAGE_DEBUG_LOGS
      ],
    }));
  • Import of the SEARCH_OBJECTS schema and handleSearchObjects handler from the search tool file.
    import { SEARCH_OBJECTS, handleSearchObjects } from "./tools/search.js";
Behavior2/5

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

No annotations are provided, so the description carries the full burden. It mentions the search behavior and examples of matches, but does not disclose critical traits such as whether this is a read-only operation, if there are rate limits, authentication requirements, or what the output format looks like (e.g., list of object names with metadata). For a search tool with zero annotation coverage, this leaves significant gaps.

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 front-loaded with the core purpose in the first sentence, followed by illustrative examples that earn their place by clarifying usage. It is brief, with no redundant or unnecessary information, making it highly efficient for an AI agent to parse.

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's moderate complexity (search with pattern matching), no annotations, and no output schema, the description is adequate but incomplete. It covers the purpose and parameter usage well, but lacks details on behavioral aspects like output format, error handling, or system constraints, which are important for an agent to use it effectively.

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

Parameters4/5

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

The schema description coverage is 100%, so the schema already documents the single parameter 'searchPattern'. The description adds value by providing concrete examples ('Account' will find Account, AccountHistory) that illustrate the pattern-matching semantics beyond the schema's generic description, enhancing understanding of how the parameter behaves in practice.

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

Purpose5/5

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

The description clearly states the specific action ('Search for Salesforce standard and custom objects') and resource ('by name pattern'), with concrete examples that distinguish it from siblings like salesforce_describe_object (which describes a single object) or salesforce_search_all (which searches across all data, not just object names).

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

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage through examples (e.g., searching for 'Account' or 'Order'), but does not explicitly state when to use this tool versus alternatives like salesforce_describe_object for detailed metadata or salesforce_search_all for broader data searches. No explicit exclusions or prerequisites are mentioned.

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/simonl77/mcp-server-salesforce'

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