Como construir um servidor Node.js MCP para integração Claude-Salesforce

Este artigo o guiará através da criação de um servidor MCP simples, porém funcional, que se integra ao Salesforce, permitindo que o Claude Desktop consulte diretamente e interaja com seus dados do Salesforce.

O que vamos construir

Criaremos um servidor MCP baseado em Node.js que permita Claude::

• Liste todas as organizações do Salesforce conectadas da sua cli do Salesforce
• Executar consultas SOQL através de avisos de linguagem pure
• Recuperar e exibir dados do Salesforce em um formato de conversação

O código completo para este projeto está disponível no Github.

Como é:

O que é MCP

O MCP é um protocolo desenvolvido pela Antrópica que permite que os modelos de IA estendam seus recursos acessando sistemas externos. No nosso caso, permite que Claude interaja com orgs do Salesforce, execute consultas e processos de dados – durante toda a conversa simples.

Vamos construí -lo!

Pré -requisitos

Antes de prosseguir com o artigo, verifique se você tem as seguintes ferramentas instaladas no seu computador:

Além disso, presume -se que você tenha uma experiência básica com o LLMS, como chatgpt, gemini, Claude, and so forth.

Configuração do projeto

Crie uma pasta para o projeto em qualquer lugar do seu computador. Vamos nomear, por exemplo, SF-MCP-SERVER. Abra a pasta no código vs.

No código VS, abre um terminal e inicie um novo projeto NPM executando o seguinte comando:

npm init -y

Instale as dependências necessárias:

npm set up @modelcontextprotocol/sdk zod
npm set up -D @varieties/node typescript

Crie uma nova pasta chamada src dentro da raiz da pasta do seu projeto, que é o SF-CMP-SERVER um.

Criar um novo arquivo dentro do src pasta chamada index.tsdeve estar dentro deste caminho ./src/index.ts.

Crie um novo arquivo chamado tsconfig.json Dentro da raiz da pasta do seu projeto e a preenchem com este código:

{
  "compilerOptions": {
    "goal": "ES2022",
    "module": "Node16",
    "moduleResolution": "Node16",
    "outDir": "./construct",
    "rootDir": "./src",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true
  },
  "embody": ["src/**/*"],
  "exclude": ["node_modules"]
}

Existe o package deal.json Arquivo Na raiz da pasta do seu projeto, ajuste seu conteúdo para garantir que ele contenha o seguinte código:

{
  "sort": "module",
  "bin": {
    "sf-mcp-server": "./construct/index.js"
  },
  "scripts": {
    "construct": "tsc && chmod 755 construct/index.js"
  },
  "information": ["build"]
}

O código completo deste arquivo está disponível no repositório do GitHub.

No closing desta parte, a pasta do projeto deve ter a seguinte estrutura:

.
├── node_modules
├── src/
│   └── index.ts
├── package-lock.json
├── package deal.json
└── tsconfig.json

A parte da codificação

Vamos começar a importar os pacotes que vamos usar e configurar o servidor. Adicione o seguinte código no topo do .src/index.ts arquivo:

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
// Importing exec from node:child_process to execute shell instructions
import { exec } from "node:child_process"; 

const server = new McpServer({
    title: "sf-mcp-server",
    model: "1.0.0",
    capabilities: {
        instruments: {},
    },
});

Agora, vamos adicionar algum código para buscar as organizações do Salesforce conectado. É melhor criar um aplicativo conectado e configurar um fluxo de autenticação se você planeja trabalhar com uma única organização, mas usaremos as organizações conectadas da CLI do Salesforce para simplificar.

Execute o sf org checklist comando no seu terminal e verifique se você tem algum orgs conectado disponível. Caso contrário, autorize uma organização que você pode usar mais longe.

Este código informa ao servidor MCP que você tem uma ferramenta que pode executar o sf org checklist --json comando no shell e passe o resultado para Claude para que ele possa entender quais orgs você autenticou. Adicione este código abaixo ao .src/index.ts arquivo:

const listConnectedSalesforceOrgs = async () => {
    return new Promise((resolve, reject) => {
        exec("sf org checklist --json", (error, stdout, stderr) => {
            if (error) {
                return reject(error);
            }
            if (stderr) {
                return reject(new Error(stderr));
            }
            strive {
                const consequence = JSON.parse(stdout);
                resolve(consequence);
            } catch (parseError) {
                reject(parseError);
            }
        });
    });
};

server.instrument("list_connected_salesforce_orgs", {}, async () => {
    const orgList = await listConnectedSalesforceOrgs();
    return {
        content material: [
            {
                type: "text",
                text: JSON.stringify(orgList, null, 2),
            },
        ],
    };
});

Ótimo! A próxima etapa é adicionar o código para executar consultas SOQL em uma das organizações conectadas.

Este código aceita um esquema de entrada do immediate que você envia para Claude no aplicativo Claude for Desktop, analisa -o para entidades separadas como targetOrg ou fields para consultar e enviar essas informações para o executeSoqlQuery função, que executa o comando sf para consultar registros usando uma consulta SOQL. Depois que a função posterior terminar de executar, seu resultado está sendo enviado ao Claude, que analisa o resultado e responde a você de uma maneira bonita no bate -papo.

Agora adicione este código após o previamente anexado:

const executeSoqlQuery = async (
    targetOrg: string,
    sObject: string,
    fields: string,
    the place?: string,
    orderBy?: string,
    restrict?: quantity
) => {
    let question = `SELECT ${fields} FROM ${sObject}`;

    if (the place) question += " WHERE " + the place;
    if (restrict) question += " LIMIT " + restrict;
    if (orderBy) question += " ORDER BY " + orderBy;

    const sfCommand = `sf knowledge question --target-org ${targetOrg} --query "${question}" --json`;

    return new Promise((resolve, reject) => {
        exec(sfCommand, (error, stdout, stderr) => {
            if (error) {
                return reject(error);
            }
            if (stderr) {
                return reject(new Error(stderr));
            }
            strive  []);
             catch (parseError) {
                reject(parseError);
            }
        });
    });
};

server.instrument(
    "query_records",
    "Execute a SOQL question in Salesforce Org",
    {
        enter: z.object({
            targetOrg: z
                .string()
                .describe("Goal Salesforce Org to execute the question towards"),
            sObject: z.string().describe("Salesforce SObject to question from"),
            fields: z
                .string()
                .describe("Comma-separated checklist of fields to retrieve"),
            the place: z
                .string()
                .non-obligatory()
                .describe("Non-obligatory WHERE clause for the question"),
            orderBy: z
                .string()
                .non-obligatory()
                .describe("Non-obligatory ORDER BY clause for the question"),
            restrict: z
                .quantity()
                .non-obligatory()
                .describe("Non-obligatory restrict for the variety of information returned"),
        }),
    },
    async ({ enter }) => {
        const { targetOrg, sObject, fields, the place, orderBy, restrict } = enter;
        const consequence = await executeSoqlQuery(
            targetOrg,
            sObject,
            fields,
            the place,
            orderBy,
            restrict
        );

        return {
            content material: [
                {
                    type: "text",
                    text: JSON.stringify(result, null, 2),
                },
            ],
        };
    }
);

Terminamos o código da funcionalidade básica deste servidor MCP, agora vamos adicionar o código para inicializar o servidor e a conexão de configuração. Anexar este código ao closing do .src/index.ts arquivo:

async operate foremost() {
    const transport = new StdioServerTransport();
    await server.join(transport);
    console.error("Salesforce MCP Server working on stdio");
}

foremost().catch((error) => {
    console.error("Deadly error in foremost():", error);
    course of.exit(1);
});

O todo .src/index.ts O arquivo deve ficar assim.

Certificando -se de que funcione

Vamos começar a testar o servidor MCP construindo nosso projeto, é uma etapa importante, não pule. UM construir A pasta será criada dentro do SF-CMP-Server, junto com o Index.js arquivo, que será usado pelo servidor MCP. Execute o seguinte comando em seu terminal para executar a compilação:

npm run construct

Agora, o aplicativo Claude for Desktop deve ser configurado para trabalhar com o MCP, ele será usado como cliente. No seu computador, navegue até o caminho em que o arquivo de configuração do Claude está localizado. Crie -o se não estiver presente.

Para macOS/Linux:

~/Library/Utility Assist/Claude/claude_desktop_config.json

Para Home windows:

C:UsersYOUR_USERNAMEAppDataRoamingClaudeclaude_desktop_config.json

Abra o Claude_desktop_config.json Arquivo no código VS e adicione o código a seguir para fazer com que o servidor MCP seja exibido no Claude para a interface do usuário do aplicativo de desktop:

{
  "mcpServers": {
    "sf-mcp-server": {
      "command": "node",
      "args": ["/ABSOLUTE/PATH/TO/PARENT/FOLDER/sf-mcp-server/build/index.js"]
    }
  }
}

Salve o arquivo e reinicie o aplicativo Claude para desktop. Você deve ver o SF-MCP-SERVER Na interface do usuário das ferramentas no aplicativo:

Tente escrever um aviso para obter suas organizações conectadas, por exemplo:

checklist linked orgs

Você deve ver um resultado semelhante:

Copie o pseudônimo da organização ou o nome de usuário e escreva o próximo immediate para realmente consultar os registros, por exemplo:

question 5 account names and web sites from the ORG_YOU_COPIED org

Então você verá algo assim:

Conclusão

Parabéns! Você construiu com sucesso um servidor MCP que conecta o Claude Desktop ao Salesforce. Agora você pode consultar seus dados do Salesforce usando linguagem pure, tornando a exploração de dados mais intuitiva e eficiente.

O que realizamos

• Construiu um servidor node.js MCP com o TypeScript
• Ferramentas implementadas para listar o Salesforce Orgs e executar consultas SOQL
• Configurado Claude Desktop para usar o servidor personalizado
• Testou a integração com consultas reais

PRÓXIMOS PASSOS

Embora este tutorial tenha usado o Salesforce CLI para simplificar, você pode desbloquear todo o poder do Salesforce, implementando a autenticação adequada com aplicativos conectados e usando diretamente as APIs do Salesforce. Esta abordagem permite:

• Fluxos de autenticação OAuth 2.0
• Acesso direto de descanso, sabão e API em massa
• Streaming em tempo actual com eventos de plataforma
• API de metadados para gerenciamento de configuração
• Operações completas do CRUD e lógica de negócios complexa

As habilidades que você aprendeu aqui se aplicam à integração de Claude com qualquer sistema ou API. Seja construindo ferramentas internas ou automatizando fluxos de trabalho, o MCP fornece uma base sólida para a criação de experiências movidas a IA.

O código completo para este projeto está disponível no Github.