AI Agent for Dynamics 365 F&O
Initialising knowledge base...
 
AI-Powered · Dynamics 365 F&O · Beta

The AI Agent that knows
every line of D365 F&O

ALM XPP MCP gives your AI assistant deep, real-time knowledge of Dynamics 365 Finance & Operations — 38 tools that search, analyze, generate and validate X++ code directly in VS Code, Cursor, or Claude.

Beta — Early Access Programme
300K+ indexed objects Any MCP-compatible IDE No data leaves your machine Token required — apply now
300K+
Indexed D365 Objects
38
AI-Powered Tools
900K+
Label Translations
5
Supported IDEs
The Protocol

Why MCP Changes Everything

The open standard that turned AI from a chat box into a real development partner.

Before MCP
  • Every integration was custom-built — M × N adapters for M apps and N tools
  • Weeks of engineering to wire one API to one assistant
  • LLMs were powerful but isolated — no access to your real code or data
After MCP
  • Build once — works with every MCP client: VS Code, Cursor, Claude, Visual Studio
  • M + N instead of M×N — one server, universal AI reach
  • What took weeks of integration now takes one JSON config block
What is MCP?

One protocol. Every AI. Every tool.

Anthropic's Model Context Protocol is a shared JSON format for connecting AI to tools. Any AI assistant that speaks MCP instantly understands any MCP server — no custom adapters, no per-platform rewrites.

Build once, integrate everywhere. Your knowledge base, your API, your code — available to every AI platform immediately.

// One server → every client
https://almxpp.com/mcp VS Code Copilot
https://almxpp.com/mcp Cursor
https://almxpp.com/mcp Claude Desktop
https://almxpp.com/mcp Visual Studio
https://almxpp.com/mcp any MCP client ∞
38 tools · 300K+ D365 objects · zero config
The Product

What is ALM XPP MCP?

An MCP server purpose-built for Dynamics 365 F&O. It indexes the entire standard codebase — every table, class, form, enum, EDT, security object, data entity, and label — and exposes it as 38 real-time AI tools inside your IDE.

Smart Search

Natural language search across 300K+ D365 F&O objects with hybrid semantic + keyword matching.

Deep Analysis

Security chain tracing, data flow analysis, execution flow mapping, best practice validation.

Code Generation

X++ templates, CoC extensions, unit tests, data entities, full Visual Studio solutions.

ROI Tracking

Every tool call tracks hours saved vs manual effort. Real-time dashboard with credits & usage analytics.

Quick Start

Get Started in 3 Steps

Create an account, grab your token, paste one config block into your IDE.

Prerequisites
Node.js ≥ 18 — required for npx/stdio mode only
Download from nodejs.org (LTS). Verify with node -v. Not required for HTTP mode.
API Token — from your Dashboard
Create an account, then go to DashboardRequest API Token. Admin approval required.
Outbound HTTPS access
Server hosted on Azure. Port 443 outbound required. No inbound ports needed.
1
Request Beta Access

Sign up with email or use Google / Microsoft SSO. Apply for your API token — admin approval required.

Create Account
2
Request Your API Token

Go to Dashboard → click "Request API Token" → wait for admin approval.

Tokens require approval & expire after 90 days.

3
Connect Your IDE

Paste one config block below into your MCP client. Start asking questions in natural language.

VS Code + GitHub Copilot
// .vscode/mcp.json
{
  "servers": {
    "almxppmcp": {
    "type": "http",
      "url": "https://almxpp.com/mcp",
      "headers": {
        "X-API-Key": "your-token"
      }
    }
  }
}
Cursor
// .cursor/mcp.json
{
  "mcpServers": {
    "almxppmcp": {
      "url": "https://almxpp.com/mcp",
      "headers": {
        "X-API-Key": "your-token"
   }
    }
  }
}
Claude Desktop
// claude_desktop_config.json
{
  "mcpServers": {
  "almxppmcp": {
      "command": "npx",
      "args": [
     "-y", "almxppmcp",
        "--api-key",
        "your-token"
   ]
    }
  }
}
Full Catalog

All 38 Tools

Every tool includes a real-world scenario — exactly what you'd ask, exactly what you get back.

Discovery & Navigation 7 tools
Find objects, explore relationships, and navigate the 300K+ object knowledge base.
search_d365_code
Natural language search across all objects with hybrid semantic + keyword matching.
Scenario: "Find all tables that store vendor invoice header data" → VendInvoiceJour, VendInvoiceInfoTable + 8 more with labels, fields, and model names.
get_object_details
Full metadata — fields, methods, relations, indexes, source code for any exact object name.
Scenario: "Get details for SalesTable" → 87 fields, 12 indexes, 15 relations, 40+ methods with X++ source.
list_objects
Exhaustive listing of D365 objects by AOT type and/or model — full index scan, every match.
Scenario: "List all data entities in ApplicationSuite" → 1,200+ entities with public OData names.
find_related_objects
Outgoing FK relations, delete actions, data sources + incoming back-references from the relation graph.
Scenario: "What objects are related to CustTable?" → 23 outgoing relations and 150+ incoming references.
find_references
Full-index scan of ALL objects referencing a name — essential impact analysis before any change.
Scenario: "Find everything that references InventDim" → 2,000 references: classes, forms, views, queries.
find_extensions
Find all CoC classes, table/form/class extensions, and event handlers for a base object.
Scenario: "Find all extensions of SalesTable" → Extension classes, CoC methods, pre/post event handlers across all models.
search_labels
Search 900K+ labels across all languages — find label ID's from text or text from ID's.
Scenario: "Find label ID for 'Purchase order'" → @SYS14731 with translations in en-US, fr, de, es, ja, zh-Hans.
Security & Governance 3 tools
Trace security chains, infer license types, and generate full governance reports across the role hierarchy.
trace_security_chain
Traverse Role → Duties → Privileges → Entry Points → Table/Form permissions in one call.
Scenario: "Trace security chain for SalesOrderMaintain" → Full hierarchy, entry points unlocked, tables it can read/write.
trace_role_license_tree
Trace the full role tree and infer the Microsoft 365 license type for each entry point (Finance, SCM, HR, Team Members…).
Scenario: "What licenses does the AccountsPayableClerk role require?" → Finance license for posting duties, Team Members for read-only views.
generate_security_governance_report
Full governance report: Role→Duty→Privilege chain, license distribution, orphan detection, over-privileged roles, optimization recommendations.
Scenario: "Generate security governance report for HSO model" → Flags 3 orphan duties, 2 over-privileged roles, maps Finance/SCM/HR licenses.
Code Generation 6 tools
Generate production-ready X++ code, templates, AOT objects, entities, queries, and telemetry scaffolding.
generate_xpp_template
X++ templates: CoC extension, table extension, event handler, runnable job, find/exist method — with real metadata.
Scenario: "Generate CoC extension for SalesTable.validateWrite" → Complete class with [ExtensionOf], correct next() call, proper return signature.
create_aot_object
Generate complete ready-to-deploy AOT XML for any object type: Table, Class, Form, Enum, EDT, View, Query, Entity, Security objects, Extensions.
Scenario: "Create AxTable HSOMyTable with fields Id, Description, CustAccount and find/exist methods" → Full XML with indexes, relations, field groups.
generate_data_entity
Complete AxDataEntityView XML with multi-table joins, automatic relation detection, OData public name, and staging table.
Scenario: "Create data entity for SalesTable joined with CustTable" → Full entity XML with field mappings, data source relations, public OData name.
generate_unit_test
SysTest scaffolding with arrange/act/assert pattern based on real object metadata — compilable X++ out of the box.
Scenario: "Generate unit tests for SalesTable" → SysTestCase class with tests for find(), validateWrite(), insert() using real field names.
generate_query
Generate X++ select statements and T-SQL queries from natural language, with correct joins, filters, ORDER BY, cross-company.
Scenario: "Open sales orders for US-001 sorted by date joined with CustTable" → Both X++ and SQL with proper joins from metadata.
generate_fdd_telemetry
Generate complete X++ Application Insights telemetry instrumentation for a custom D365 FDD/RDD — based on the HSOMonitoring framework.
Scenario: "Generate telemetry for FDD030 SalesProcessor class" → Concrete telemetry class, CoC stubs with processEvent/logTrace, elapsed time tracking, custom properties visible in App Insights.
Quality & Validation 5 tools
Validate X++ and AOT code against best practices, detect performance issues, measure complexity, get fix suggestions.
validate_best_practices
Multi-severity rule engine: security vulnerabilities, transaction issues, error handling, hardcoded strings — on index or live disk source.
Scenario: "Validate best practices for SalesFormLetter" → 2 Critical (SQL in loop, missing ttsbegin), 5 Warnings (no field list in select).
validate_aot_pattern
Validate AOT XML structure against standard schema: required elements, naming conventions (ISV prefix, PascalCase), field groups, security entry points.
Scenario: "Validate my HSOSalesTableExtension" → Checks naming, label usage, property completeness, field group assignments.
detect_performance_issues
Detect N+1 queries, queries inside loops, missing field lists, row-by-row insert/update, missing firstonly — on index or live disk.
Scenario: "Detect performance issues in InventOnHandReserve" → Select inside while loop (N+1), missing index on InventDimId join.
explain_code_complexity
Cyclomatic complexity, nesting depth, LOC, parameter count per method. Ranks all methods by complexity for an entire object.
Scenario: "Analyze complexity of SalesLineType" → initFromSalesLine() = complexity 14 (High Risk), 6 nesting levels, refactoring recommended.
suggest_refactoring
Concrete refactoring actions with before/after X++ examples: extract method, guard clauses, set-based operations, strategy pattern.
Scenario: "Suggest refactoring for PurchFormLetter.run()" → Extract validation method, replace switch with strategy, reduce nesting with guard clauses.
Tracing & Diagrams 3 tools
Visualize object relationships, generate interactive Mermaid diagrams, map complete business processes.
get_relation_graph
O(1) pre-computed bidirectional relation graph: ALL outgoing FK/DeleteAction/DataSource edges + all incoming back-references in one call.
Scenario: "Show relation graph for SalesTable" → SalesLine (1:N), CustTable (N:1), InventTable (N:1), 40+ incoming references from forms, entities, CoC classes.
generate_diagram
Mermaid diagrams rendered directly in your IDE: ER (entity-relationship with cardinality), flow (execution call graph), security (role→privilege chain).
Scenario: "Generate ER diagram for PurchTable" → Mermaid diagram with cardinality and FK labels, renderable in VS Code, Cursor, Claude, any Markdown viewer.
map_business_process
Map a named business process (Order-to-Cash, Procure-to-Pay, Hire-to-Retire…) to its complete object chain: forms, tables, classes, entities, reports.
Scenario: "Map Order-to-Cash process" → SalesTable → SalesLine → InventTrans → CustPackingSlip → CustInvoice → LedgerJournal with Mermaid flow diagram.
Data & Knowledge Base 3 tools
Find OData entities, diagnose runtime errors, inspect knowledge base statistics.
find_entity_for_table
Scan all indexed AxDataEntityView objects to find entities exposing a table for OData/DMF — returns public entity name, IsPublic status, key fields.
Scenario: "Which entities expose SalesTable?" → SalesOrderHeaderV2Entity (public OData), SalesOrderHeaderEntity (legacy) + 3 more with OData URL.
find_error_patterns
Match error messages or symptoms to known D365 F&O patterns — resolves label IDs from InfoLog text, returns root cause + step-by-step resolution.
Scenario: "Cannot edit a record in SalesTable. Update conflict." → Pattern: OptimisticConcurrency violation. 5-step resolution with code example.
get_index_stats
Knowledge base health check: total chunks, unique objects, breakdown by AOT type and model, loaded D365 version.
Scenario: "How large is the knowledge base?" → 312K objects: 14K tables, 45K classes, 8.9K forms, 1.2K entities across 120 models.
Azure DevOps Integration 7 tools
Manage work items, analyze PR quality, auto-create tasks with D365 naming conventions, all from your AI assistant.
ado_query_workitems
Run WIQL queries or plain-language filters to list work items — bugs, tasks, user stories, features — with full metadata.
Scenario: "Show all active bugs assigned to me in sprint 12" → Table with ID, title, state, assignee, priority, area, iteration.
ado_analyze_workitem
Deep analysis of a work item: reads description + acceptance criteria + attachments (images), cross-references with D365 KB objects mentioned in the text.
Scenario: "Analyze work item #4512" → Extracts D365 objects referenced, suggests impacted tables/classes, flags missing acceptance criteria.
ado_post_comment
Post a markdown comment to a work item's discussion thread — requires explicit user confirmation before posting.
Scenario: "Post my analysis as a comment on WI #4512" → Markdown comment with D365 impact report posted to Discussion section.
ado_list_prs
List Pull Requests with filters: status (Active/Completed/Abandoned), author, target branch. Lists all repos if no repo specified.
Scenario: "Show active PRs targeting main branch by Alim" → PR table with ID, title, branches, review status, linked work items.
ado_analyze_pr_impact
Deep D365 code impact analysis for every X++/AOT XML file in a PR: best practice violations, upgrade risk, CoC/extension conflicts — produces a ready-to-post review comment.
Scenario: "Analyze PR #42 impact" → 2 Critical BP violations (SQL in loop), 1 broken CoC target ([Hookable(false)]), 1 extension conflict — risk: 🔴 HIGH.
ado_post_pr_comment
Post the D365 review analysis as a PR thread — top-level or inline on a specific file/line. Always requires explicit user confirmation.
Scenario: "Post the analysis to PR #42" → Review thread posted with critical issues, warnings, and fix suggestions visible to the whole team.
ado_create_task
Create a Task work item following the FDD/RDD/IDD naming convention — auto-increments task number, creates Git branch, sets parent/related links, assigns to developer, adds CC list.
Scenario: "Create task for WI #5227 (RDD302), assign to dev@company.com, notify lead@company.com" → Task "RDD302 - 2 - Service Quotation…" created, branch RDD302_Task_6554 created in repo, linked automatically.
Operations & Custom Model 4 tools
Detect upgrade risks against standard code, analyze your custom model on disk, inspect live files, check server health.
analyze_upgrade_impact
Cross-reference every CoC target, event handler, and extension in your custom model against the indexed D365 standard — detects removed objects, changed signatures, deprecated APIs, [Hookable(false)] blocks.
Scenario: "Check upgrade impact of my custom model" → 2 broken CoC (method changed in v10.0.38), 1 deprecated RunBase API, 1 missing base object — prioritized risk report.
list_custom_model_objects
List all X++ objects in your custom model directory directly from disk — always reflects the latest uncommitted state (not the index).
Scenario: "What's in my custom model?" → 48 objects: 12 table extensions, 8 classes, 6 form extensions, 5 CoC classes — with disk paths.
explain_for_business
Explain any D365 object in plain business language — no code, no field names. Ideal for functional consultants, PMs, and business analysts.
Scenario: "Explain CustTable for a business analyst" → "The Customer master stores name, address, credit limit, and payment terms. It's connected to sales orders, invoices, and payment history."
healthcheck
Check MCP server readiness: index status, chunk count, loaded D365 version, custom model path, uptime.
Scenario: "Is the server healthy?" → ✅ Healthy · 312K objects loaded · D365 10.0.38 · Uptime: 4d 12h · Custom model: not configured.
ROI Calculator

Calculate Your Savings

See the exact dollar value ALM XPP MCP delivers to your team based on your real hourly rate and usage.

Your Setup
Adjust inputs above to see your ROI breakdown.
Your Monthly Impact
Hours Saved / Month
Cost Avoided / Month
Projected Annual Saving
ROI Multiplier
Time Saved Per Common Task
Side by Side

With vs Without ALM XPP MCP

Real time savings on the most common D365 F&O development tasks.

TaskTimeWithoutWith ALM XPP MCP
Find a table
15m5s
Open AOT, expand nodes, scroll 300K objects, inspect eachsearch_d365_code → instant results with metadata
Trace security chain
30m3s
Navigate Role→Duty→Privilege across dozens of AOT nodestrace_security_chain → full chain + Mermaid diagram
Write a CoC extension
20m5s
Look up signatures, write boilerplate, check naming conventionsgenerate_xpp_template → correct CoC with next() call
Create a data entity
45m10s
Define fields, set properties, wire relations — tedious and error-pronegenerate_data_entity → complete entity XML with joins
Understand new code
30m5s
Read source, trace calls, decode patterns from scratchexplain_framework_pattern → "RunBase/FormLetter…"
Review a Pull Request
60m15s
Manually review X++ changes, check BP rules, look up upgrade notesado_analyze_pr_impact → full D365 BP + upgrade risk report
Create a development task
10m5s
Open DevOps, fill form, name task manually, create branch, link WIado_create_task → task + branch + links created with correct naming
Access

Beta Early Access

ALM XPP MCP is in active beta. Apply for access, get your API token and start using all 38 tools. Pricing will be introduced at general availability.

BETA
Beta Access
Apply — token required

Create an account, request your API token, and get full access once approved by the team.

  • All 38 tools — no restrictions during beta
  • API token for VS Code, Cursor, Claude
  • 300K+ indexed objects from D365 standard
  • Usage dashboard with ROI tracking
  • Admin-reviewed token approval
Request Beta Access

Pricing will be introduced when the product reaches general availability.

FAQ

Frequently Asked Questions

ALM XPP MCP is an MCP server purpose-built for Dynamics 365 F&O. It indexes the entire D365 standard codebase (300K+ objects) and exposes 38 AI-powered tools that your IDE's AI assistant (Copilot, Claude, Cursor) can call in real time to search, analyze, generate, and validate X++ code.

Any MCP-compatible client: VS Code with GitHub Copilot Chat (agent mode), Cursor, Claude Desktop, Visual Studio with Copilot, and Copilot Studio. The server uses standard HTTP transport — any tool that speaks MCP can connect.

No. The server indexes standard D365 F&O code only. Your custom model files stay on your machine. The "custom model" tools read files locally — nothing is uploaded to the server.

You create an account, generate an API token from your Dashboard, and pass it as an X-API-Key header. Tokens are SHA-256 hashed at rest, sessions use cryptographic random tokens, and user data is AES-256-GCM encrypted. Tokens expire after 90 days.

Only for npx/stdio mode (Claude Desktop, Cursor stdio config). Node.js ≥ 18 is required. Download from nodejs.org and verify with node -v. For HTTP mode in VS Code or Cursor, no Node.js is needed.

We'll introduce paid plans (Developer, Enterprise) with credit-based usage. Preview users will receive generous transition terms. All usage data and ROI metrics from the preview carry over to your account.