The MCP Salesforce Connector enables LLMs to interact with Salesforce data and APIs through the following capabilities:
Run SOQL Queries (run_soql_query): Execute Salesforce Object Query Language queries to retrieve structured data.
Run SOSL Searches (run_sosl_search): Perform searches across multiple objects and fields (e.g., FIND {John Smith} IN ALL FIELDS).
Get Object Fields (get_object_fields): Retrieve metadata for Salesforce objects, including field names, labels, and data types.
Record Management: Retrieve (get_record), create (create_record), update (update_record), and delete (delete_record) records for any Salesforce object.
Tooling API (tooling_execute): Make GET, POST, PATCH, and DELETE calls to the Salesforce Tooling API (e.g., access ApexClass metadata).
Apex REST (apex_execute): Call custom Apex REST endpoints with GET, POST, PATCH, and DELETE methods.
Direct REST API (restful): Make arbitrary REST API calls to any Salesforce endpoint with custom paths, methods, query parameters, and request bodies.
Supports OAuth, Salesforce CLI, and username/password authentication, and works with both production and sandbox environments.
Enables interaction with Salesforce data through SOQL queries, SOSL searches, and various operations including retrieving metadata, managing records (create, read, update, delete), executing Tooling API requests, running Apex REST requests, and making direct REST API calls to Salesforce.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@MCP Salesforce Connector show me the last 10 opportunities created this week"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
A Model Context Protocol (MCP) server implementation for Salesforce integration, allowing LLMs to interact with Salesforce data through SOQL queries and SOSL searches.
Execute SOQL (Salesforce Object Query Language) queries
Perform SOSL (Salesforce Object Search Language) searches
Retrieve metadata for Salesforce objects, including field names, labels, and types
List all available SObjects - Discover standard and custom objects
Retrieve, create, update, and delete records
Execute Tooling API requests
Execute Apex REST requests
Make direct REST API calls to Salesforce
Related MCP server: Salesforce MCP Integration
To use this server with the Model Context Protocol, you need to configure it in your claude_desktop_config.json file. Add the following entry to the mcpServers section:
{
"mcpServers": {
"salesforce": {
"command": "uvx",
"args": [
"--from",
"mcp-salesforce-connector",
"salesforce"
],
"env": {
"SALESFORCE_ACCESS_TOKEN": "SALESFORCE_ACCESS_TOKEN",
"SALESFORCE_INSTANCE_URL": "SALESFORCE_INSTANCE_URL",
"SALESFORCE_DOMAIN": "SALESFORCE_DOMAIN"
}
}
}
}run_soql_query - Execute SOQL queries against Salesforce
run_sosl_search - Perform SOSL searches across objects
get_object_fields - Retrieve field metadata for specific objects
list_sobjects - List all available SObjects (standard and custom)
get_record - Retrieve a specific record by ID
create_record - Create a new record
update_record - Update an existing record
delete_record - Delete a record
bulk_create_records - Create multiple records in a single operation
bulk_update_records - Update multiple records (must include Id field)
bulk_delete_records - Delete multiple records using record IDs
tooling_execute - Execute Tooling API requests
apex_execute - Execute Apex REST requests
restful - Make direct REST API calls to Salesforce
Note on Salesforce Authentication Methods
This server supports four authentication methods:
OAuth (Recommended): Set SALESFORCE_ACCESS_TOKEN and SALESFORCE_INSTANCE_URL as environment variables.
Client Credentials: Set SALESFORCE_CLIENT_ID and SALESFORCE_CLIENT_SECRET for OAuth 2.0 Client Credentials flow. This is useful for server-to-server integrations.
Salesforce CLI (Default Org): If no OAuth env vars are set, the server will try to use the active Salesforce CLI default org from the current workspace (via sf org display --json or sfdx force:org:display --json). Optionally set SALESFORCE_CLI_TARGET_ORG to target a specific org.
Username/Password (Legacy): If SALESFORCE_ACCESS_TOKEN and SALESFORCE_INSTANCE_URL are not set, the server will fall back to using SALESFORCE_USERNAME, SALESFORCE_PASSWORD, and SALESFORCE_SECURITY_TOKEN.
Environment Configuration
SALESFORCE_DOMAIN (Optional): Set to test to connect to a Salesforce sandbox environment. If not set or left empty, the server will connect to the production environment.
SALESFORCE_CLI_TARGET_ORG (Optional): When using the Salesforce CLI authentication method, set this to target a specific org alias or username instead of the default org.
Executes an Apex REST request
| Name | Required | Description | Default |
|---|---|---|---|
| data | No | Data for POST/PATCH requests | |
| action | Yes | The Apex REST endpoint to call (e.g., '/MyApexClass') | |
| method | No | The HTTP method (default: 'GET') | GET |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden for behavioral disclosure. It does not mention whether the operation is destructive, idempotent, or requires specific permissions, leaving critical traits unknown.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very short (6 words) and to the point. While it could be more informative, it wastes no words and is appropriate for a simple tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations and no output schema, the description omits crucial context such as return format, error behavior, and prerequisites (e.g., Apex class must be exposed). This inadequately prepares an agent to use the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and already defines all three parameters. The description adds no additional meaning beyond what the schema provides, so baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Executes an Apex REST request' clearly identifies the verb and resource, distinguishing it from generic REST or tooling operations among siblings. However, it lacks explicit context that this refers to Salesforce Apex classes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like 'restful' or 'tooling_execute'. The agent has no information about prerequisites or preferred scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Creates multiple records of a specified SObject type in bulk.
| Name | Required | Description | Default |
|---|---|---|---|
| data | Yes | A list of records to create. Each record is a dictionary of field names and values. | |
| object_name | Yes | The API name of the Salesforce SObject (e.g., 'Account', 'MyCustomObject__c'). |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description fails to disclose behavioral traits such as error handling (e.g., partial success), idempotency, or rate limits relevant to a bulk operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence with no superfluous words. It is appropriately concise and front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (bulk operation with two parameters) and lack of output schema, the description is incomplete. It does not explain the response format, error handling, or recommend usage for large data volumes.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, but the description adds no additional meaning beyond the schema's parameter descriptions, which are already present. The baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it creates multiple records in bulk, distinguishing it from the sibling 'create_record' tool for single records. However, it could more explicitly contrast with 'create_record'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool vs alternatives like 'create_record' for single records or 'bulk_update_records'. The description lacks context for proper tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Deletes multiple records of a specified SObject type in bulk, given their IDs.
| Name | Required | Description | Default |
|---|---|---|---|
| record_ids | Yes | A list of record IDs (strings) to delete. | |
| object_name | Yes | The API name of the Salesforce SObject (e.g., 'Account', 'MyCustomObject__c'). |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It only mentions deletion, but does not disclose potential partial failures, error handling, or constraints. Minimal 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, no redundant words, directly states the core functionality. Efficient and front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a destructive bulk operation with 2 parameters and no output schema, the description lacks information on batch limits, partial success, error behavior, and side effects. Insufficient for an agent to fully understand tool behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with well-documented parameters. The description adds no extra meaning beyond the schema; baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'deletes', resource 'multiple records of a specified SObject type', and method 'in bulk, given their IDs'. It distinguishes from sibling tools like delete_record (single) and bulk_create_records.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives such as delete_record for single deletes or other bulk operations. No prerequisites or exclusions mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Updates multiple records of a specified SObject type in bulk. Each record must have an 'Id' field.
| Name | Required | Description | Default |
|---|---|---|---|
| data | Yes | A list of records to update. Each record is a dictionary of field names and values, and *must* include an 'Id' field. | |
| object_name | Yes | The API name of the Salesforce SObject (e.g., 'Account', 'MyCustomObject__c'). |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided; description mentions Id requirement but omits error handling, transactional behavior, permissions, or side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, no redundant words, front-loaded with essential information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Describes bulk update and Id requirement but lacks failure handling, limits, or return value information, especially with no output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%; description adds context like 'API name' for object_name and reinforces Id requirement, providing value beyond schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states verb 'updates', resource 'multiple records', and scope 'in bulk', distinguishing it from siblings like 'bulk_create_records' and 'update_record'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Implies bulk usage but lacks explicit when-to-use vs alternatives (e.g., for single records use update_record) and no exclusions or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Creates a new record
| Name | Required | Description | Default |
|---|---|---|---|
| data | Yes | The data for the new record | |
| object_name | Yes | The name of the Salesforce object (e.g., 'Account', 'Contact') |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations available, the description must disclose behavioral traits. It only states 'Creates a new record' without mentioning that this is a write operation, authentication requirements, potential side effects (e.g., creation of dependent records), or error conditions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
While the description is short, it is under-specified and fails to earn its place. A single vague phrase is not concise; it omits critical information that must be inferred.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (nested object parameter, no output schema), the description is severely incomplete. It does not explain return values, error handling, or the behavior of the 'data' parameter. Sibling tools exist but no differentiation is provided.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the schema already documents both parameters. The description adds no meaning beyond the schema; it does not clarify the format of 'data' or provide examples. Baseline of 3 is appropriate since the schema is self-sufficient.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Creates a new record' is a tautology that simply restates the tool name 'create_record' without specifying the target system (Salesforce) or distinguishing it from sibling tools like 'bulk_create_records'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives such as 'bulk_create_records' or 'update_record'. The description lacks any context about prerequisites or scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Deletes a record
| Name | Required | Description | Default |
|---|---|---|---|
| record_id | Yes | The ID of the record to delete | |
| object_name | Yes | The name of the Salesforce object (e.g., 'Account', 'Contact') |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden but only states the action 'deletes'. It fails to disclose irreversibility, required permissions, or side effects, which are critical for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely short (3 words), sacrificing necessary behavioral and usage details. This is under-specification, not good conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simple 2-parameter tool and no output schema, the description should at least differentiate from sibling tools and indicate scope (single record, Salesforce context). It fails to do so.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Parameter meanings are fully covered by the schema (100% coverage). The description adds no extra context, but baseline score is 3 due to complete schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Deletes a record' is a tautology that adds no new information beyond the tool name. It does not differentiate from sibling tools like bulk_delete_records, which also delete records.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives (e.g., bulk_delete_records for multiple records). The description implies single-record deletion but does not state it explicitly or mention prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Retrieves field names and types for a Salesforce object. Use this to discover available fields before writing SOQL queries.
Output is CSV format: name,label,type,updateable
| Name | Required | Description | Default |
|---|---|---|---|
| object_name | Yes | The Salesforce object API name (e.g., 'Account', 'Contact', 'Store__c') |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided. Description mentions output format (CSV) and that it retrieves metadata, but lacks details on authentication, rate limits, or side effects. Adequate but not comprehensive.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three concise sentences with no redundancy. Front-loaded with purpose, then usage, then output format. Every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given simplicity (1 param, no output schema), description covers purpose, usage, and output format. It is sufficient for a discovery tool, though could mention potential limits or error cases.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The single parameter 'object_name' is fully described in the schema (100% coverage). The description adds no additional semantic beyond the schema, so baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states it retrieves field names and types for a Salesforce object, with a specific verb ('Retrieves') and resource. Distinguishes from sibling tools like 'list_sobjects' and 'run_soql_query' by focusing on schema discovery.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit use case: 'Use this to discover available fields before writing SOQL queries.' This guides when to use it, though it does not name alternative tools for other scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Retrieves a specific record by ID. Returns all fields - prefer SOQL with specific fields for token efficiency.
| Name | Required | Description | Default |
|---|---|---|---|
| format | No | Output format: 'compact' (default), 'json' | compact |
| record_id | Yes | The 15 or 18 character Salesforce record ID | |
| object_name | Yes | The Salesforce object API name (e.g., 'Account', 'Contact') |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries the burden. It discloses that the tool returns all fields, which is key behavioral context. It does not mention error handling or side effects, but for a read operation, this is adequate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences, front-loaded with action. No superfluous words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple retrieval tool with no output schema, the description covers purpose and a key trade-off. It lacks details on error cases but is fairly complete given the tool's simplicity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so description does not need to add param details. The description adds minimal extra meaning beyond the schema, only the context of retrieving by ID and efficiency hint.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool retrieves a specific record by ID and returns all fields. It differentiates from sibling tools like run_soql_query by hinting at token efficiency trade-offs.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description advises preferring SOQL with specific fields for token efficiency, implying this tool is for full-record retrieval. However, it does not explicitly state when to use or not use this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Retrieves a list of all available Salesforce SObjects (standard and custom).
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description bears the full burden. It states a read operation ('retrieves') but does not disclose any additional behavioral traits such as caching, authentication requirements, or side effects. This is minimally adequate for a read-only list tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that front-loads the purpose. Every word earns its place; there is no redundancy or unnecessary information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has no parameters and no output schema, the description adequately conveys the tool's purpose. It could mention the return format or any filtering behavior, but it is sufficient for a simple list operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are zero parameters, and schema description coverage is 100%, so the baseline is 4. The description adds no parameter details, which is appropriate given the absence of parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly states that the tool retrieves a list of all available Salesforce SObjects, including both standard and custom. This clearly defines the action and resource, and it distinguishes from sibling tools like 'get_object_fields' and 'run_soql_query' which serve different purposes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description does not provide explicit when-to-use or when-not-to-use guidance, but given the simplicity of the tool with no parameters, the context is clear. The tool is self-explanatory, and the absence of alternatives or exclusions is acceptable for a straightforward list operation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Makes a direct REST API call to Salesforce
| Name | Required | Description | Default |
|---|---|---|---|
| data | No | Data for POST/PATCH requests | |
| path | Yes | The path of the REST API endpoint (e.g., 'sobjects/Account/describe') | |
| method | No | The HTTP method (default: 'GET') | GET |
| params | No | Query parameters for the request |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries full responsibility. It fails to disclose authentication requirements, error handling, rate limits, or idempotency behavior. For a tool making arbitrary API calls, this is a significant gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise phrase, front-loaded with the core action. It is efficient, though extremely brief, but still earns its place by clearly stating the tool's purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's generic nature with 4 parameters and no output schema, the description lacks essential context such as return values, error responses, or prerequisites. It is too minimal for an agent to use reliably.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema provides 100% coverage of parameters with descriptions, so the baseline is 3. The description adds no additional meaning beyond what the schema already conveys.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Makes' and the resource 'direct REST API call to Salesforce'. It distinguishes itself from other sibling tools that specialize in specific Salesforce operations like create_record or run_soql_query.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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 many specialized siblings, an agent needs explicit hints about scenarios (e.g., custom endpoints not covered by other tools) to select appropriately.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Executes a SOQL query against Salesforce.
TOKEN OPTIMIZATION GUIDELINES:
Always SELECT only the fields you need (never SELECT *)
Use LIMIT to restrict results (start with LIMIT 10, increase if needed)
Use WHERE clauses to filter data server-side
Default output is CSV format (most token-efficient)
Use format='json' only when you need nested data structure
You can always run additional queries if you need more data
Example efficient query: SELECT Id, Name FROM Account WHERE IsActive = true LIMIT 20
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | The SOQL query to execute. Always include LIMIT clause and select only needed fields. | |
| format | No | Output format: 'csv' (default, most compact), 'compact' (JSON no whitespace), 'json' (full JSON) | csv |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must convey behavioral traits. It implies a read-only operation by executing a query, but it does not explicitly state that it does not modify data or mention any side effects. The description adds context about token efficiency but lacks explicit disclosure of read-only nature.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured: first sentence states purpose, followed by a bullet-point list of guidelines, and ends with an example. Every sentence provides useful information for efficient tool usage, with no unnecessary fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given that the schema fully documents both parameters and sibling tools include similar data access tools, the description provides sufficient context for proper tool selection and invocation. The guidelines cover efficient query construction and output format options.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% coverage for its 2 parameters. The description adds value by explaining the format default and when to use alternate output formats, and provides guidance on writing efficient queries (select only needed fields, LIMIT, WHERE). This goes beyond the schema definitions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Executes a SOQL query against Salesforce.' This specifies the action (executes), the resource (SOQL query against Salesforce), and differentiates it from sibling tools like run_sosl_search, get_record, and data mutation tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides 'TOKEN OPTIMIZATION GUIDELINES' with best practices: select needed fields, use LIMIT, WHERE clauses, and default CSV output. It also gives an example efficient query. However, it does not explicitly mention when not to use this tool (e.g., for SOSL searches or simple record lookups).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Executes a SOSL search against Salesforce.
TOKEN OPTIMIZATION: Use RETURNING clause to limit fields and objects. Example: FIND {searchterm} RETURNING Account(Id, Name), Contact(Id, Name) LIMIT 10
| Name | Required | Description | Default |
|---|---|---|---|
| format | No | Output format: 'csv' (default), 'compact', 'json' | csv |
| search | Yes | The SOSL search to execute. Use RETURNING to specify fields and LIMIT for result count. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must convey behavioral traits. It states that the tool executes a search and includes a token optimization note, but does not disclose whether the operation is read-only (likely, but not explicit), any rate limits, or side effects. The description is insufficient for full behavioral understanding.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise: one sentence for the purpose, followed by a token optimization note and an example. It is front-loaded with the key action and avoids any fluff or repetition. Every sentence contributes value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the basic function and parameter usage via example, but lacks details about return values (no output schema) and what the different formats (csv, compact, json) actually produce. Given the tool executes a search and outputs data, the absence of return format details is a gap, though the schema partially covers formats.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3. The description adds a token optimization emphasis and an example, but the schema already describes the 'search' parameter with RETURNING and LIMIT usage. The 'format' parameter is fully defined in the schema with enum. No meaningful additional semantics are provided beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it executes a SOSL search against Salesforce, which is a specific verb-resource pair. It distinguishes itself from sibling tools like run_soql_query (which runs SOQL) by using the term SOSL, a distinct Salesforce query language for cross-object searches.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides an example and a token optimization tip, implying usage context (e.g., using RETURNING and LIMIT). However, it lacks explicit guidance on when to use SOSL versus other tools like run_soql_query, and does not mention when not to use this tool or alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Executes a Tooling API request
| Name | Required | Description | Default |
|---|---|---|---|
| data | No | Data for POST/PATCH requests | |
| action | Yes | The Tooling API endpoint to call (e.g., 'sobjects/ApexClass') | |
| method | No | The HTTP method (default: 'GET') | GET |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, and the description does not disclose authentication needs, rate limits, error handling, or side effects. For a tool that executes arbitrary API requests, this is insufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise (one sentence) but lacks structure or additional details. It is adequate for a simple tool but could benefit from more context.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given three parameters, no output schema, and multiple sibling tools, the description is incomplete. It does not describe return values, error behavior, or when this tool is preferred over others.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with clear descriptions for all parameters. The description adds no additional meaning beyond the schema, so baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it executes a Tooling API request, which is a specific Salesforce API. It distinguishes from siblings like restful or apex_execute, though it could be more explicit about the Tooling API's purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives like restful or run_soql_query. The agent must infer usage from the tool name and context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Updates an existing record
| Name | Required | Description | Default |
|---|---|---|---|
| data | Yes | The updated data for the record | |
| record_id | Yes | The ID of the record to update | |
| object_name | Yes | The name of the Salesforce object (e.g., 'Account', 'Contact') |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavioral traits. It only states 'Updates', which implies mutation, but omits details like idempotency, return values, permissions, or error handling. This is insufficient for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence of four words, which is concise but too terse. Given the tool has three parameters and a nested object, more context is needed. It sacrifices informativeness for brevity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema and multiple sibling tools, the description lacks essential context. It does not mention return values, error scenarios, or the relationship to other tools like 'bulk_update_records' or 'apex_execute'. The update behavior is under-specified.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema describes all three parameters with 100% coverage. However, the description adds no value beyond the schema; for the 'data' nested object, it only says 'The updated data for the record' without clarifying structure or constraints.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Updates an existing record' clearly states the action and resource. It is distinct from sibling tools like 'create_record' (creates new) and 'delete_record' (deletes), making the purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies use when modifying an existing record by ID, but lacks explicit guidance on when not to use (e.g., for bulk operations or if record doesn't exist). No alternatives are mentioned despite many sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v0.1.15bulk_create_recordsbulk_delete_recordsbulk_update_recordsget_object_fields1 field changedInput schema / properties / object_name / descriptionPrevious value: -"The name of the Salesforce object (e.g., 'Account', 'Contact')"New value: +"The Salesforce object API name (e.g., 'Account', 'Contact', 'Store__c')"get_record3 fields changedInput schema / properties / formatAdded value: +{
+ "default": "compact",
+ "description": "Output format: 'compact' (default), 'json'",
+ "enum": [
+ "compact",
+ "json"
+ ],
+ "type": "string"
+}Input schema / properties / object_name / descriptionPrevious value: -"The name of the Salesforce object (e.g., 'Account', 'Contact')"New value: +"The Salesforce object API name (e.g., 'Account', 'Contact')"Input schema / properties / record_id / descriptionPrevious value: -"The ID of the record to retrieve"New value: +"The 15 or 18 character Salesforce record ID"list_sobjectsrun_soql_query2 fields changedInput schema / properties / formatAdded value: +{
+ "default": "csv",
+ "description": "Output format: 'csv' (default, most compact), 'compact' (JSON no whitespace), 'json' (full JSON)",
+ "enum": [
+ "csv",
+ "compact",
+ "json"
+ ],
+ "type": "string"
+}Input schema / properties / query / descriptionPrevious value: -"The SOQL query to execute"New value: +"The SOQL query to execute. Always include LIMIT clause and select only needed fields."run_sosl_search2 fields changedInput schema / properties / formatAdded value: +{
+ "default": "csv",
+ "description": "Output format: 'csv' (default), 'compact', 'json'",
+ "enum": [
+ "csv",
+ "compact",
+ "json"
+ ],
+ "type": "string"
+}Input schema / properties / search / descriptionPrevious value: -"The SOSL search to execute (e.g., 'FIND {John Smith} IN ALL FIELDS')"New value: +"The SOSL search to execute. Use RETURNING to specify fields and LIMIT for result count."v1.0.0apex_executecreate_recorddelete_recordget_object_fieldsget_recordrestfulrun_soql_queryrun_sosl_searchtooling_executeupdate_recordEach tool targets a distinct operation: CRUD, bulk CRUD, queries, metadata, and direct API calls. Overlaps like get_record vs run_soql_query are clarified by different access patterns (ID vs query). Apex and tooling executes are differentiated by API type.
Most tools follow snake_case verb_noun pattern (e.g., create_record, run_soql_query). Exceptions include 'restful' (single word) and plural in bulk tools (bulk_create_records) vs singular in standard tools (create_record), causing minor inconsistency.
14 tools cover a broad Salesforce use case without being excessive. Each tool has a clear purpose, and the count is well-scoped for a comprehensive connector.
The tool set covers CRUD, bulk operations, queries, searches, object metadata, and direct API calls. Minor gaps include absence of upsert or describe metadata operations, but core workflows are fully supported.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
The HubSpot MCP Server acts as a bridge that enables AI assistants and Large Language Models to securely interact with HubSpot CRM data through natural conversation, without requiring users to understand complex API structures. It provides read-only access to standard CRM objects (contacts, companies, deals, tickets, products, invoices, and more) and their associations, secured via OAuth 2.0, allowing AI agents to perform tasks like summarizing deals, fetching company updates, and looking up record changes.
API-first CRM for LLMs - contacts, companies, deals and activities over a native MCP server.
The Mercado Pago MCP Server implements the Model Context Protocol to provide AI agents and LLMs with access to Mercado Pago's APIs and tools within compatible development environments. It acts as an intermediary that translates Mercado Pago resources into executable functions (tools) that AI applications can invoke to perform actions and automate flows. The server simplifies integration, enables using documentation to implement or improve code, and optimizes operations through natural language interactions without manual implementations.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/smn2gnt/MCP-Salesforce'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
