October 27, 2026

open-source-knowledge

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 or identity providers like Keycloak—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 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 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 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:

// 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;
      `,
    }),
  }
);

Connect Langdock to your enterprise stack

We design and build custom MCP servers, Integrations API actions, SSO/SCIM provisioning, and n8n workflows around Langdock.

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.