# Langdock enterprise integrations: MCP servers, Integrations API, and architecture patterns

> How to connect Langdock to SharePoint, Confluence, Jira, HubSpot, n8n, and custom internal APIs using OAuth permission inheritance, Model Context Protocol (MCP), and the Integrations API.

For AI agents: curated site map at [https://www.devolute.org/llms.txt](https://www.devolute.org/llms.txt). Canonical HTML (preferred for search engines): [https://www.devolute.org/en/insights/open-source/langdock-integrations-mcp-api-enterprise-guide](https://www.devolute.org/en/insights/open-source/langdock-integrations-mcp-api-enterprise-guide).

- Language: en
- Published: 2026-10-27
- Markdown URL: https://www.devolute.org/en/insights/open-source/langdock-integrations-mcp-api-enterprise-guide.md

## Langdock integrations: from isolated chat to connected enterprise workflows

Five concrete architecture patterns using native OAuth connectors, custom MCP servers, the Integrations API, and n8n.

Rolling out an enterprise AI workspace often stalls at the same point: employees appreciate having GDPR-compliant access to models from OpenAI, Anthropic, Mistral, and Llama, but they still have to copy and paste context between their browser tabs, ticket queues, CRM records, and internal wikis.

**Langdock** addresses this with three distinct integration layers: **native OAuth connectors**, **Model Context Protocol (MCP) servers** (both inbound and outbound), and a programmatic **Integrations API** (`https://api.langdock.com`). Choosing the right layer—and pairing it with workflow engines like **[n8n](/en/agency/n8n-automation-agency)** or identity providers like **[Keycloak](/en/agency/keycloak-sso-implementation)**—determines whether your rollout stays a novelty or becomes reliable infrastructure.

## The three integration layers in Langdock

| Integration mechanism | Best suited for | Authentication & security model | Operational trade-off |
|---|---|---|---|
| **Native connectors** (SharePoint, Confluence, Jira, HubSpot, Slack, Google Drive) | Immediate read/write access to standard enterprise SaaS and Data Center apps | Per-user OAuth 2.0 with 1:1 source-app permission mirroring and SharePoint sensitivity-label filtering | Zero maintenance, but limited to pre-built actions |
| **External MCP servers** (HTTP/SSE to Langdock) | Connecting internal microservices, SQL/vector databases, or shared tool catalogs across multiple AI clients | OAuth 2.0 or API key; auto-discovers up to 60 tools and 50 resources per integration | Reusable across Langdock, Cursor, and Claude; requires hosting the MCP endpoint |
| **Integrations API** (`/integrations/v1`) | Custom workspace actions and event triggers managed as code in CI/CD | Workspace API key (`INTEGRATION_API` scope) + per-integration auth configuration and `requiresConfirmation` flags | Runs inside Langdock's sandboxed runtime (`ld.request`); Langdock-specific |

## 5 high-impact integration ideas and architecture patterns

### 1. Permission-safe knowledge retrieval across SharePoint & Confluence Data Center

Most internal RAG prototypes fail security reviews because a shared service account indexes documents that only specific departments should see.

- **How it works:** Connect Microsoft SharePoint and Atlassian Confluence (Cloud or self-hosted Data Center) using Langdock's native OAuth 2.0 integration. Queries execute under the signed-in employee's token, inheriting exact space, page, and folder permissions.
- **Governance hardening:** Enable a **Sensitivity Label Policy** in the workspace so SharePoint files tagged *Confidential — Board* or *HR Restricted* are withheld automatically before context reaches any model.
- **When to extend:** If you also maintain technical documentation or structured records in PostgreSQL, pair Langdock with a dedicated **[RAG & PostgreSQL/pgvector backend](/en/agency/postgresql-ai-backend)** exposed via MCP.

### 2. Two-way engineering & support triage with Jira and GitHub/GitLab

Support engineers and product managers spend hours translating customer bug reports into structured backlog tickets and checking release status.

- **How it works:** Wire a dedicated Langdock Assistant to **Jira** (or Jira Data Center), **Confluence**, and a GitHub/GitLab MCP server.
- **Workflow in practice:**
  1. A support engineer pastes a customer thread or error trace into the assistant.
  2. The assistant searches Jira for duplicate issues, pulls the relevant runbook from Confluence, and drafts a root-cause summary.
  3. Using a Jira `create_issue` or `add_comment` action—with `requiresConfirmation: true`—the user reviews and approves the ticket payload before it is written.

### 3. Revenue & account intelligence with HubSpot, Salesforce, and ERP data

Sales and account teams rarely need generic email drafting; they need fast synthesis across CRM history, open support tickets, and contract terms before a client call.

- **How it works:** Combine the native **HubSpot** or **Salesforce** connector (contacts, deals, activities) with a custom Integration Action that queries order status or invoice balances from your ERP (e.g., **[Odoo](/en/agency/odoo-erp-implementation-consulting-development)** or SAP) via `/integrations/v1/{integrationId}/actions/create`.
- **Guardrail:** Keep financial and ERP lookups read-only (`GET` via `ld.request`), and require explicit user confirmation before logging call notes or updating deal stages in HubSpot.

### 4. Delegating heavy multi-step automation from Langdock to self-hosted n8n

Langdock excels at interactive human-in-the-loop reasoning, while **[n8n](/en/agency/n8n-automation-agency)** excels at deterministic background orchestration, retries, and connecting 1,000+ technical endpoints.

- **Architecture pattern:**
  - **Langdock → n8n:** Create a custom Langdock Action that sends a validated JSON payload to a signed n8n webhook (for example, onboarding a supplier, generating a PDF dossier, or syncing records across three legacy databases).
  - **n8n → Langdock:** Use Langdock **Triggers** (`/integrations/v1/{integrationId}/triggers/create`) or the Assistant API so an incoming webhook in n8n (such as a new compliance questionnaire or security alert) invokes a specialized Langdock agent and posts the structured result into Slack, Teams, or Mattermost.

### 5. Exposing Langdock workspace agents to developer tools via the Langdock Agent MCP Server

Not every employee works inside the Langdock web UI—software engineers and data scientists spend their day in Cursor, Claude Code, or internal portals.

- **How it works:** Langdock provides its own MCP server endpoint at `https://api.langdock.com/mcp` (or `https://<your-domain>/api/public/mcp` for dedicated deployments), authenticated via `Authorization: Bearer <API_KEY>` with the Agent API scope.
- **Available MCP tools:**
  - `find_agent`: Look up a domain agent's ID by name (e.g., *"Security Architecture Reviewer"* or *"GDPR DPIA Assistant"*).
  - `ask_agent`: Send a prompt and multi-turn `messageHistory` to that agent, leveraging its pre-configured instructions, model choice, and connected SharePoint/Confluence knowledge bases directly from Cursor or your IDE.
  - `ask_custom_agent`: Spin up an ephemeral agent configuration for one-off programmatic tasks.

## Managing Langdock integrations as code

Avoid building business-critical integrations by hand in a browser UI without version control. Using the Integrations API (`INTEGRATION_API` scope), engineering teams can store action scripts and input schemas in Git and deploy them through CI/CD:

```javascript
// Example: Updating a governed Langdock Action from CI/CD
const response = await fetch(
  `https://api.langdock.com/integrations/v1/${integrationId}/actions/${actionId}`,
  {
    method: "PUT",
    headers: {
      Authorization: `Bearer ${process.env.LANGDOCK_INTEGRATION_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      name: "Lookup ERP Order Status",
      description: "Fetches current fulfilment status from internal ERP API",
      requiresConfirmation: false,
      inputFields: [
        {
          label: "Order Number",
          type: "TEXT",
          description: "ERP order reference (e.g. SO-2026-1042)",
          required: true,
        },
      ],
      code: `
        const res = await ld.request({
          method: "GET",
          url: "https://erp-gateway.internal.example.com/v1/orders/" + encodeURIComponent(data.input.orderNumber)
        });
        return res.json;
      `,
    }),
  }
);
```