MCP Server Salesforce

0 forks

0 stars

Free

What is mcp-server-salesforce

mcp-server-salesforce is an implementation of the Model Context Protocol (MCP) designed to facilitate interactions with Salesforce. Developed by kazuki1213, this server enables AI systems to securely access and manipulate Salesforce data. It provides a structured environment where notes can be stored and analyzed, and Salesforce objects can be queried, created, updated, or deleted. The server's architecture supports both custom URI schemes for notes and Salesforce objects, making it a versatile tool for managing and analyzing business data.

How to Use mcp-server-salesforce

To use mcp-server-salesforce, you must configure authentication credentials for Salesforce. This can be done using environment variables or a .env file in the project directory. Required credentials include your Salesforce username, password, security token, and optionally, the login domain.

Once set up, the server can be utilized for various tasks:

Notes Management: You can add, store, and summarize notes using a custom URI scheme. This is particularly useful for organizing information and generating summaries that can be brief or detailed based on your preference.
Salesforce Interactions: The server provides several tools for interacting with Salesforce. You can query data using SOQL, create new records, update existing ones, or delete records. Each action requires specific arguments like object names or data fields.
Prompts and Analysis: Use prompts to summarize stored notes or analyze Salesforce data. You can specify how detailed the summaries should be or limit the number of records analyzed.

Key Features of mcp-server-salesforce

Notes Storage System:
- Custom note:// URI scheme for accessing and managing individual notes.
- Each note is stored with a name, description, and text/plain mimetype.
- Summarization capabilities with optional detail levels.
Salesforce Object Management:
- Custom salesforce:// URI scheme for accessing and manipulating Salesforce objects.
- Supports JSON data format for object resources.
- Comprehensive tools for querying, creating, updating, and deleting Salesforce records.
Prompts for Analysis:
- summarize-notes: Generate summaries of stored notes with style preferences.
- analyze-salesforce-data: Analyze Salesforce data with options to specify the object and limit the number of records.
Authentication and Configuration:
- Seamless integration with Salesforce through environment configurations.
- Supports both environment variables and .env files for flexibility.
Development and Deployment:
- Continuous integration and deployment pipelines using GitHub Actions.
- Easy installation and configuration for different environments.

This server is a powerful tool for businesses looking to enhance their data management and analysis capabilities within Salesforce, offering a streamlined interface for interacting with both notes and Salesforce data.

CI License: MIT Python Version A Model Context Protocol server implementation for interacting with Salesforce

Components

Resources

The server implements resources in two categories:

Notes storage system:

Custom note:// URI scheme for accessing individual notes
Each note resource has a name, description and text/plain mimetype

Salesforce objects:

Custom salesforce:// URI scheme for accessing Salesforce objects and records
Each object resource has a name, description and application/json mimetype

Prompts

The server provides the following prompts:

summarize-notes: Creates summaries of all stored notes
Optional "style" argument to control detail level (brief/detailed)
Generates prompt combining all current notes with style preference
analyze-salesforce-data: Analyzes data from a Salesforce object
Required "object" argument to specify Salesforce object name (e.g., Account, Contact)
Optional "limit" argument to control maximum number of records (default: 10)
Retrieves and formats data for analysis

Tools

The server implements the following tools:

Notes management:

add-note: Adds a new note to the server
Takes "name" and "content" as required string arguments
Updates server state and notifies clients of resource changes

Salesforce interactions:

salesforce-query: Execute a SOQL query against Salesforce
Takes "query" as a required string argument (valid SOQL query)
Returns query results as JSON
salesforce-create: Create a new record in Salesforce
Takes "object" (e.g., "Account") and "data" (field values) as required arguments
Returns the ID of the created record
salesforce-update: Update an existing Salesforce record
Takes "object", "id", and "data" as required arguments
Updates the specified record with new field values
salesforce-delete: Delete a Salesforce record
Takes "object" and "id" as required arguments
Deletes the specified record

Configuration

To use the Salesforce functionality, you need to set up authentication credentials. The server supports environment variables or a .env file in the project root. Required environment variables:

SALESFORCE_USERNAME: Your Salesforce username (usually email)
SALESFORCE_PASSWORD: Your Salesforce password
SALESFORCE_SECURITY_TOKEN: Your Salesforce security token
SALESFORCE_DOMAIN: (Optional) Salesforce login domain (default: "login")

Quickstart

Install

Claude Desktop

On MacOS: ~/Library/Application\ Support/Claude/claude_desktop_config.json On Windows: %APPDATA%/Claude/claude_desktop_config.json Development/Unpublished Servers Configuration

"mcpServers": {
"mcp-server-salesforce": {
"command": "uv",
"args": [
"--directory",
"/path/to/mcp-server-salesforce",
"run",
"mcp-server-salesforce"

Published Servers Configuration

"mcpServers": {
"mcp-server-salesforce": {
"command": "uvx",
"args": [
"mcp-server-salesforce"

Development

Building and Publishing

The project uses GitHub Actions for CI/CD:

CI Pipeline: Automatically runs tests, type checking, and linting on every push and pull request
CD Pipeline: Automatically builds and publishes to PyPI when a new version tag is pushed To prepare a release:

Update the version in pyproject.toml
Create and push a tag:

git tag v0.0.x
git push origin v0.0.x

This will trigger the automatic release process. For manual builds:

Sync dependencies and update lockfile:

uv sync

Build package distributions:

uv build

This will create source and wheel distributions in the dist/ directory. 3. Publish to PyPI:

uv publish

Note: You'll need to set PyPI credentials via environment variables or command flags:

Token: --token or UV_PUBLISH_TOKEN
Or username/password: --username/UV_PUBLISH_USERNAME and --password/UV_PUBLISH_PASSWORD

Debugging

Since MCP servers run over stdio, debugging can be challenging. For the best debugging experience, we strongly recommend using the MCP Inspector. You can launch the MCP Inspector via npm with this command:

npx @modelcontextprotocol/inspector uv --directory /path/to/mcp-server-salesforce run mcp-server-salesforce

Upon launching, the Inspector will display a URL that you can access in your browser to begin debugging.

How to Use

To use the mcp-server-salesforce, follow these steps:

Visit https://github.com/kazuki1213/mcp-server-salesforcehttps://github.com/kazuki...
Follow the setup instructions to create an account (if required)
Connect the MCP server to your Claude Desktop application
Start using mcp-server-salesforce capabilities within your Claude conversations

Additional Information

Created

March 10, 2025

Company

kazuki1213

Related MCP Servers

Start building your own MCP Server

Interested in creating your own MCP Server? Check out the official documentation and resources.

Learn More