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

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 — 40 tools that search, analyze, generate and validate X++ code directly in VS Code, Cursor, or Claude.

Experimental Preview — Free & Unlimited
300K+ indexed objects Any MCP-compatible IDE No data leaves your machine No credit card required
300K+
Indexed D365 Objects
40
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
almxppmcp VS Code Copilot
almxppmcp Cursor
almxppmcp Claude Desktop
almxppmcp Visual Studio
almxppmcp any MCP client ∞
40 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 40 real-time AI tools inside your IDE.

Smart Search

Natural language search across 300K+ D365 F&O objects with hybrid TF-IDF + 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
Create an Account

Sign up with email or use Google / Microsoft SSO. No credit card needed.

Sign Up Free
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://server/mcp",
      "headers": {
   "X-API-Key": "your-token"
 }
    }
  }
}
Cursor
// .cursor/mcp.json
{
  "mcpServers": {
    "almxppmcp": {
      "url": "https://server/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 40 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 TF-IDF + 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.
Scenario: "Get details for SalesTable" → 87 fields, 12 indexes, 15 relations, 40+ methods with X++ source.
list_objects
Exhaustive listing by AOT type and/or model — full index scan.
Scenario: "List all data entities in ApplicationSuite" → 1,200+ entities with public OData names.
find_related_objects
Outgoing relations (FKs, delete actions, data sources) + incoming references.
Scenario: "What objects are related to CustTable?" → 23 outgoing relations and 150+ incoming references.
find_references
Impact analysis — exhaustive full scan of ALL objects referencing a name.
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.
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 IDs from text or text from IDs.
Scenario: "Find label ID for 'Purchase order'" → @SYS14731 with translations in en-US, fr, de, es, ja, zh-Hans.
Security & Governance 2 tools
Trace security chains and generate governance reports across the full role hierarchy.
trace_security_chain
Trace Role → Duties → Privileges → Entry Points → Table/Form Permissions.
Scenario: "Trace the security chain for SalesOrderMaintain" → Full hierarchy, entry points unlocked, tables it can read/write.
generate_security_governance_report
Full governance report: entry points, license types, orphan detection, over-privileged role warnings.
Scenario: "Generate security governance report" → Scans all Roles, flags 3 orphan duties, 2 over-privileged roles, infers Finance/SCM/HR licenses.
Code Generation 6 tools
Generate production-ready X++ code, templates, solutions, entities, and integration scaffolding.
generate_xpp_template
X++ templates: CoC, table extension, event handler, job, find method — with extensibility checks.
Scenario: "Generate CoC extension for SalesTable.validateWrite" → Complete class with [ExtensionOf], correct next() call, proper signature.
generate_d365_solution
Complete deployable Visual Studio solution from a JSON spec.
Scenario: "Generate a solution adding CreditScore field to SalesTable" → Full .sln, .csproj, table extension XML, EDT, ready to build.
generate_data_entity
Complete AxDataEntityView XML with multi-table joins and automatic relation detection.
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.
Scenario: "Generate unit tests for SalesTable" → SysTestCase class with tests for find(), validateWrite(), insert() using real field names.
generate_integration_code
OData read/write, batch job, service class, data import templates.
Scenario: "Generate OData write integration for SalesOrderHeaderV2Entity" → C# HttpClient with auth, JSON payload, error handling.
generate_query
X++ select and T-SQL queries with correct joins, filters, ORDER BY, cross-company.
Scenario: "Open sales orders for US-001 sorted by date" → Both X++ select and T-SQL with proper joins from metadata.
Quality & Validation 5 tools
Validate code against best practices, detect performance issues, measure complexity.
validate_best_practices
Security, performance, transactions, error handling — multi-severity rule engine.
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 naming and property patterns.
Scenario: "Validate my HSOSalesTableExtension" → Checks naming, label usage, property completeness, field group assignments.
detect_performance_issues
Query N+1, loop inefficiencies, missing indexes, large record sets.
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 per method with risk assessment.
Scenario: "Analyze complexity of SalesLineType" → initFromSalesLine() = complexity 14 (High Risk), 6 nesting levels.
suggest_refactoring
Concrete refactoring actions with before/after examples.
Scenario: "Suggest refactoring for PurchFormLetter.run()" → Extract validation, replace switch with strategy, reduce nesting with guard clauses.
Tracing & Flow 4 tools
Follow data through fields, trace execution call chains, and generate visual diagrams.
trace_data_flow
Trace how a specific field flows through the system — forms, classes, queries.
Scenario: "Trace SalesTable.SalesStatus" → Set by updateSalesStatus(), read by 23 classes, displayed on 4 forms, filtered in 6 queries.
trace_execution_flow
Static call-chain analysis from any method, up to 6 levels deep.
Scenario: "Trace execution from SalesFormLetter.run()" → run() → validate() → checkCreditLimit() → CustCreditMan.check().
generate_diagram
Mermaid diagrams: ER (entity-relationship), flow (execution), security (chain).
Scenario: "Generate ER diagram for PurchTable" → Mermaid diagram with cardinality and FK labels, renderable in any Markdown viewer.
map_business_process
Map a business process (Order-to-Cash, Procure-to-Pay…) to its complete object chain.
Scenario: "Map Order-to-Cash process" → SalesTable → SalesLine → InventTrans → CustPackingSlip → CustInvoice → LedgerJournal.
Data & Entities 4 tools
Find data entities, generate queries, and diagnose errors.
find_entity_for_table
Find data entities that expose a table for OData/DMF integrations.
Scenario: "Which entities expose SalesTable?" → SalesOrderHeaderV2Entity (public OData), SalesOrderHeaderEntity (legacy) + 3 more.
generate_query
X++ select + T-SQL from natural language with correct joins and filters.
Scenario: "All open sales orders for US-001 sorted by date" → Both X++ and SQL with proper joins.
find_error_patterns
Match error messages to known D365 F&O patterns with root cause and resolution.
Scenario: "Cannot edit a record in SalesTable. Update conflict." → Pattern: OptimisticConcurrency violation. 5-step resolution.
get_index_stats
Knowledge base statistics: total chunks, objects, breakdown by type and model.
Scenario: "How large is the knowledge base?" → 312K objects: 14K tables, 45K classes, 8.9K forms, 1.2K entities across 120 models.
Learning & Patterns 5 tools
Learn from existing patterns, compare objects, understand frameworks, get business-friendly explanations.
find_similar_implementations
Find objects structurally similar to a given object — learn from proven patterns.
Scenario: "Find objects similar to SalesFormLetter" → PurchFormLetter (92%), ProjFormLetter (87%), InventFormLetter (85%).
compare_objects
Side-by-side structural comparison of two objects.
Scenario: "Compare SalesTable vs PurchTable" → 34 shared fields, 12 unique to Sales, 8 unique to Purch, different security models.
explain_framework_pattern
Identify and explain D365 F&O framework patterns used by an object.
Scenario: "What pattern does SalesFormLetter use?" → "RunBase/FormLetter: Controller orchestrates, validate() checks, run() posts."
explain_for_business
Explain objects in non-technical business terms — for functional consultants and PMs.
Scenario: "Explain CustTable for business users" → "Customer master data: name, address, payment terms. Connected to 150+ objects."
generate_technical_doc
Generate comprehensive markdown documentation for any object or entire model.
Scenario: "Document ProjTable" → Full markdown: purpose, field table, relations diagram, method signatures, security mapping.
Operations & Custom Model 7 tools
Analyze your custom code, detect upgrade risks, validate live files, manage model health.
analyze_custom_model
Model-wide complexity analysis: all X++ objects, cyclomatic complexity, health summary.
Scenario: "Analyze my custom model" → 48 objects, avg complexity 4.2, 3 methods flagged as High Risk (>15).
analyze_upgrade_impact
Cross-reference every CoC, event handler, extension against standard codebase for upgrade risk.
Scenario: "Check upgrade impact" → 2 broken CoC (method changed in v10.0.38), 1 deprecated API, 1 missing base object.
get_live_object_details
Read custom model objects directly from disk — always reflects latest unsaved changes.
Scenario: "Show live HSOSalesTableExtension" → Reads the XML file, shows current fields/methods including uncommitted changes.
validate_live_best_practices
Best-practice checks reading current files on disk.
Scenario: "Validate HSOInventBatchHandler" → 1 Critical (ttsbegin without ttscommit), 2 Warnings (select * instead of field list).
detect_live_performance_issues
Performance analysis on custom code from live files.
Scenario: "Check performance of HSOSalesProcessor" → N+1 query in processLines() loop, missing index hint.
list_custom_model_objects
List all objects in your custom model directory — always reflects latest file system state.
Scenario: "What's in my custom model?" → 48 objects: 12 table extensions, 8 classes, 6 form extensions, 5 CoC classes.
healthcheck
Check AI Agent health — index status, uptime, version.
Scenario: "Is the server healthy?" → Healthy, 312K objects loaded, Uptime: 4d 12h, Version: 1.0.0.
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 — tediousgenerate_data_entity → complete entity with joins
Understand new code
30m5s
Read source, trace calls, decode patterns from scratchexplain_framework_pattern → "RunBase/FormLetter…"
Access

Experimental Preview — Free

All 40 tools. No restrictions. No credit card. Free during preview.

EXPERIMENTAL
Full Access — Free
$0 during preview

Create an account, get your API token, and start immediately.

  • All 40 tools — no restrictions
  • Unlimited usage during preview
  • API token for VS Code, Cursor, Claude
  • 300K+ indexed objects from D365 standard
  • No credit card required
Create Account & Get Token

Pricing will be introduced when the product exits preview.

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 40 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.