Table of Contents

Documentation MCP Server

Query the full Dynamicweb 10 documentation from your AI assistant

The Dynamicweb Documentation MCP server exposes the full Dynamicweb 10 documentation as a queryable tool inside your AI assistant. Instead of switching to a browser and searching docs by hand, you ask your editor — "what is a PriceProvider?" — and it reads the documentation for you and answers in context.

It works for two audiences:

  • Regular users — ask plain-language questions about features, concepts, and configuration and get answers grounded in the official docs.
  • Developers — pull API references, class definitions, extensibility points, and code patterns directly into your coding assistant while you work.

This article covers what it is, how to install it, and how to use it from both angles.

What it is

Model Context Protocol (MCP) is an open standard that lets AI assistants connect to external tools and data sources. The Dynamicweb Documentation MCP server is an MCP endpoint backed by a DocsBot knowledge base trained on the Dynamicweb 10 documentation.

When connected, your assistant gains a search tool. Any time you ask something about Dynamicweb, the assistant can query the documentation, retrieve the relevant sections, and answer using that source material — with references back to the original articles.

The endpoint is:

https://api.docsbot.ai/teams/4E0lh5ABtrBXB6OLOAoQ/bots/TTpjMI8paZHKOt4bPkAI/mcp/

The server requires authorization, but not with a username, password, or API key. It uses OAuth: the first time your client connects, it opens a consent screen on docsbot.ai in your browser where you select the knowledge base and allow access. The client caches the resulting token, so this is a one-time step per client. See The authorization step below.

What you can use it for

The most valuable uses fall into a few buckets:

  • Concept lookups — "What is a PriceProvider?", "How does indexing work in Dynamicweb?", "What's the difference between a Feed and a Repository?"
  • Configuration help — how to set up a feature, what a setting does, where something lives in the admin
  • Extensibility and API reference — provider types, base classes, method signatures, namespaces, and the patterns to subclass or extend them
  • Code-assist grounding — while writing C# or Razor against Dynamicweb, your assistant can verify class names and APIs against the real docs instead of guessing

Installation

Every MCP-capable client follows the same two steps: register the server URL, then complete a one-time authorization in the browser. Where the configuration is stored, and whether the server becomes available in a single project or in all your projects, depends on the client. The sections below cover the authorization flow and the exact installation steps for Claude Code, Visual Studio Code with GitHub Copilot, and Codex.

The authorization step

Authorization works the same way in every client. When the client connects to the server for the first time and you trigger authentication, your browser opens the Authorize MCP Server Access screen on docsbot.ai:

The Authorize MCP Server Access screen on docsbot.ai

Select Dynamicweb 10 Documentation GPT in the dropdown and click Allow Access. The browser then confirms that authentication succeeded:

The Authentication Successful confirmation page

Close the browser window and return to your editor. The access token is cached by the client, so you will not be asked to authorize again unless you revoke access from your DocsBot account settings.

Claude Code

Claude Code runs as a CLI in a terminal and as an extension in VS Code and other IDEs. Both share the same configuration, so you install and authorize once and it works in both places.

To add the server, run this in any terminal, including the VS Code integrated terminal:

claude mcp add --transport http dynamicweb-docs https://api.docsbot.ai/teams/4E0lh5ABtrBXB6OLOAoQ/bots/TTpjMI8paZHKOt4bPkAI/mcp/

The --scope flag controls where the server is available:

  • Without a flag (local scope, the default): available only to you, and only in the project folder you ran the command from
  • --scope user: available to you in all projects on your machine. Use this if you want the documentation server everywhere
  • --scope project: written to a .mcp.json file in the project root, intended to be committed to version control so your whole team gets the server

Then authorize the server:

  1. Start Claude Code by running claude in the terminal
  2. Run /mcp and select dynamicweb-docs
  3. Choose Authenticate (or reconnect the server); your browser opens the DocsBot consent screen described above
  4. Approve access in the browser and return to the terminal; the server shows as connected and the search tool becomes available

With --scope project, the resulting .mcp.json in the project root looks like this:

{
  "mcpServers": {
    "dynamicweb-docs": {
      "type": "http",
      "url": "https://api.docsbot.ai/teams/4E0lh5ABtrBXB6OLOAoQ/bots/TTpjMI8paZHKOt4bPkAI/mcp/"
    }
  }
}
Tip

If the server later shows as disconnected, run /mcp and reconnect it. The cached authorization is reused, so you won't go through the browser flow again.

Visual Studio Code with GitHub Copilot

MCP servers registered in VS Code itself are used by GitHub Copilot in agent mode. To add the server:

  1. Open the Command Palette (Ctrl+Shift+P) and run MCP: Add Server
  2. Select HTTP (HTTP or Server-Sent Events) as the server type
  3. Enter the server URL from above
  4. Enter dynamicweb-docs as the server ID
  5. Choose where to install it: Workspace stores it in .vscode/mcp.json in the current project, which you can commit to share with your team; Global stores it in the mcp.json file in your user profile and makes it available in all your workspaces
  6. Confirm that you trust the server when VS Code asks, and allow it to start
  7. When the server reports that it needs authentication, allow the sign-in; this opens the DocsBot consent screen described above

To verify, open Copilot Chat, switch to Agent mode, and click the tools icon to confirm the search tool from dynamicweb-docs is listed.

You can also configure the server by hand. In .vscode/mcp.json (workspace) or in the user-level configuration (run MCP: Open User Configuration):

{
  "servers": {
    "dynamicweb-docs": {
      "type": "http",
      "url": "https://api.docsbot.ai/teams/4E0lh5ABtrBXB6OLOAoQ/bots/TTpjMI8paZHKOt4bPkAI/mcp/"
    }
  }
}

Manage the server later from the MCP SERVERS - INSTALLED section in the Extensions view, or with the MCP: List Servers command.

Note

If you are on a Copilot Business or Enterprise plan, an organization admin must enable the MCP servers in Copilot policy before MCP servers will work

Codex

The Codex CLI and the Codex IDE extension share the same configuration file, so this only needs to be done once. To add and authorize the server, run:

codex mcp add dynamicweb-docs --url https://api.docsbot.ai/teams/4E0lh5ABtrBXB6OLOAoQ/bots/TTpjMI8paZHKOt4bPkAI/mcp/
codex mcp login dynamicweb-docs

The login command opens the DocsBot consent screen described above. The server is stored in ~/.codex/config.toml and applies to all your projects. To scope it to a single project instead, add it to a .codex/config.toml file in the project root (trusted projects only):

[mcp_servers.dynamicweb-docs]
url = "https://api.docsbot.ai/teams/4E0lh5ABtrBXB6OLOAoQ/bots/TTpjMI8paZHKOt4bPkAI/mcp/"

To verify, start a Codex session and run /mcp to confirm the server is connected and exposes its tools.

Other clients

Any client that supports remote HTTP MCP servers with OAuth works the same way: register the URL and complete the browser authorization when prompted. For clients that only support local stdio servers, bridge the connection with mcp-remote, which handles the OAuth flow and opens the same consent screen:

{
  "mcpServers": {
    "dynamicweb-docs": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://api.docsbot.ai/teams/4E0lh5ABtrBXB6OLOAoQ/bots/TTpjMI8paZHKOt4bPkAI/mcp/"
      ]
    }
  }
}

Using it as a regular user

You don't need to know any special commands. Ask questions in plain language, and mention Dynamicweb so the assistant knows to reach for the docs.

Example — concept question:

read dynamicweb documentation. what is a priceprovider

The assistant searches the documentation and answers:

A PriceProvider is a Dynamicweb extensibility point — a piece of code that handles product price calculation in Ecommerce. It lives in the Dynamicweb.Ecommerce.Prices namespace as an abstract base class you can subclass to control how prices are resolved. The platform ships with a DefaultPriceProvider as the out-of-the-box implementation, which you can replace or extend.

The answer comes with references back to the original documentation articles so you can read further.

More examples to try:

  • "How do I set up a product feed in Dynamicweb?"
  • "What's the difference between a paragraph and an item in Dynamicweb?"
  • "Where do I configure email marketing recipients?"
  • "Explain how the Dynamicweb indexing pipeline works."
Tip

Leading with "read the Dynamicweb documentation" or "check the docs" nudges the assistant to query the MCP server rather than answer from general knowledge.

Using it as a developer

For development work, the value is grounding your coding assistant in the real API surface so it stops inventing class names and gives you patterns that actually compile.

Example — finding the right extensibility point:

I need to apply contract-specific pricing per customer. Check the Dynamicweb docs — what should I extend and what do I override?

The assistant retrieves the PriceProvider documentation and tells you to subclass PriceProvider from Dynamicweb.Ecommerce.Prices, which methods to override, and how it's registered relative to the DefaultPriceProvider.

Example — scaffolding from a verified API:

Using the Dynamicweb documentation, write a skeleton custom PriceProvider that fetches prices from an external ERP. Include the namespace, the base class, and the method signatures I need to override.

Because the assistant pulls the actual class and signatures from the docs first, the generated skeleton matches the real platform API.

Example — verifying while coding:

While writing C# or Razor against Dynamicweb, ask mid-task:

Is OrderService the right service to load an order by ID, and what method do I call? Check the docs.

The assistant confirms the class, namespace, and method against the documentation instead of guessing — useful for the parts of the API you don't have memorized.

Patterns that work well for developers:

  • Ask for namespaces and base classes explicitly — "what namespace is X in?"
  • Ask for the override list when extending providers — "what methods do I override on X?"
  • Ground code generation — "using the docs, write…" produces far more reliable output than asking cold.
  • Use it as a fact-checker on assistant-generated code before you trust it.

Notes and limitations

  • The knowledge base reflects the published Dynamicweb 10 documentation. For undocumented internals or very recent changes, verify against source
  • The assistant decides when to call the search tool. If it answers without searching, prompt it explicitly to check the documentation
  • Answers are only as current as the underlying documentation set
Improve this doc
To top