Реализация сервера протокола контекста модели (MCP) для интеграции с Salesforce, позволяющая LLM взаимодействовать с данными Salesforce посредством запросов SOQL и поиска SOSL.
Выполнение запросов SOQL (Salesforce Object Query Language)
Выполнение поиска SOSL (Salesforce Object Search Language)
Получение метаданных объектов Salesforce, включая имена полей, метки и типы
Список всех доступных SObjects — обнаружение стандартных и пользовательских объектов
Получение, создание, обновление и удаление записей
Выполнение запросов Tooling API
Выполнение запросов Apex REST
Выполнение прямых вызовов REST API к Salesforce
Related MCP server: Salesforce MCP Integration
Чтобы использовать этот сервер с протоколом контекста модели, необходимо настроить его в файле claude_desktop_config.json. Добавьте следующую запись в раздел mcpServers:
{
"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 — выполнение запросов SOQL к Salesforce
run_sosl_search — выполнение поиска SOSL по объектам
get_object_fields — получение метаданных полей для конкретных объектов
list_sobjects — список всех доступных SObjects (стандартных и пользовательских)
get_record — получение конкретной записи по ID
create_record — создание новой записи
update_record — обновление существующей записи
delete_record — удаление записи
bulk_create_records — создание нескольких записей за одну операцию
bulk_update_records — обновление нескольких записей (должно включать поле Id)
bulk_delete_records — удаление нескольких записей с использованием их ID
tooling_execute — выполнение запросов Tooling API
apex_execute — выполнение запросов Apex REST
restful — выполнение прямых вызовов REST API к Salesforce
Примечание о методах аутентификации в Salesforce
Этот сервер поддерживает четыре метода аутентификации:
OAuth (рекомендуется): Установите SALESFORCE_ACCESS_TOKEN и SALESFORCE_INSTANCE_URL в качестве переменных окружения.
Учетные данные клиента (Client Credentials): Установите SALESFORCE_CLIENT_ID и SALESFORCE_CLIENT_SECRET для потока OAuth 2.0 Client Credentials. Это полезно для интеграций типа «сервер-сервер».
Salesforce CLI (организация по умолчанию): Если переменные окружения OAuth не установлены, сервер попытается использовать активную организацию Salesforce CLI по умолчанию из текущей рабочей области (через sf org display --json или sfdx force:org:display --json). При необходимости установите SALESFORCE_CLI_TARGET_ORG для выбора конкретной организации.
Имя пользователя/пароль (устаревший метод): Если SALESFORCE_ACCESS_TOKEN и SALESFORCE_INSTANCE_URL не установлены, сервер вернется к использованию SALESFORCE_USERNAME, SALESFORCE_PASSWORD и SALESFORCE_SECURITY_TOKEN.
Конфигурация окружения
SALESFORCE_DOMAIN (необязательно): Установите значение test для подключения к песочнице (sandbox) Salesforce. Если не установлено или оставлено пустым, сервер будет подключаться к рабочей среде (production).
SALESFORCE_CLI_TARGET_ORG (необязательно): При использовании метода аутентификации Salesforce CLI установите это значение, чтобы выбрать конкретный псевдоним организации или имя пользователя вместо организации по умолчанию.
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.
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_recordScored across 14 tools
Each 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.
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.
