AI Integrations
EA GraphLink’s MCP Server connects your Sparx EA repository to Cursor and Claude Code: AI-assisted IDEs used by engineers and technical architects. This is the MCP interface path, and it reaches an audience that every other EA integration completely misses.
Copilot integration reaches business stakeholders in Teams and Outlook. Agentforce integration reaches Salesforce users in the CRM. Both are valuable. Neither reaches the people making technical decisions in the code and modeling environment: the systems engineers, software architects, and MBSE architects who spend their working days in IDEs, not in business platforms.
When EA GraphLink connects to Cursor and Claude Code, architects and engineers can query the live EA repository from inside their development environment. Approved interfaces for a component. Services that depend on a specific API. Requirements that trace to a given element. Technology standards an architecture must conform to. These questions arise during design work and development: and they get answered from the live repository without leaving the IDE, without opening an EA client, without interrupting an architect.
The MDG Technology definition governs what Cursor and Claude Code can access. EA GraphLink transforms the physical repository schema using the MDG Technology definition. If the MDG quality is poor: inconsistent element definitions, missing relationships, incomplete application-layer content: the answers engineers receive will reflect those gaps. MDG readiness is assessed in Discover and established in Deploy. The engineering community will expose repository quality issues quickly and visibly.
Architecture-aware development and design: not because anyone enforced it, but because the answers are available where the questions arise.
Your current state: A systems engineer is designing a new service. She needs to know: what are the approved integration patterns for services in this domain? What systems already depend on the API she’s proposing to modify? What requirements from the architecture repository trace to this component? She has three options: open an EA client (requires a license she may not have), ask an architect (requires scheduling or a response time she doesn’t have), or proceed without the information (the usual outcome). She proceeds without the information.
Your future state: The same engineer is in Cursor. She types a query into the MCP-connected Claude Code tool: “What are the approved interfaces for the payment service, and which downstream systems depend on them?” EA GraphLink receives the query via the MCP Server, returns the relevant repository content, and Claude Code surfaces the answer inside Cursor. The engineer has architecture context in thirty seconds without leaving the IDE, without opening an EA client, and without interrupting an architect.
Architecture governance shifts from periodic review to continuous awareness. The repository becomes a live reference rather than a periodic artifact that delivery teams consult, if at all, during formal review cycles.
Every other EA integration in this guide targets business stakeholders, executives, and architecture architects. This integration targets the engineering community.
Engineers and technical architects are the people translating architecture decisions into built systems. They are the people most likely to make choices: about interfaces, dependencies, integration patterns, technology selection: that either align with the architecture model or diverge from it. When they diverge, it is rarely deliberate. It is because the architecture information was not available when the decision was being made.
Making architecture information available in the IDE does not eliminate the need for architecture governance. It reduces the number of governance failures caused by information absence. That is a different problem from the one Copilot and Agentforce solve: and it is a significant one.
Repository Queries During System Design in Cursor
An engineer is designing the application component structure for a new service in Cursor. She queries: “What ArchiMate application components currently implement the customer notification business service?” Claude Code queries EA GraphLink and returns the current component map: existing implementations, their technology stacks, and the interfaces they expose. The new service design can be made consistent with the existing landscape rather than duplicating or conflicting with it.
Architecture-Aware Code Generation
Claude Code is generating integration boilerplate for a new API endpoint. Before generating the code, the engineer queries EA GraphLink via Cursor: “What interface patterns are approved for services in the payments domain?” Claude Code retrieves the approved patterns from the repository: authentication protocols, data format standards, error handling conventions: and generates code that conforms to those patterns rather than generic patterns that may conflict with architecture standards.
Dependency Impact Queries During Development
An engineer is about to modify a shared API. She queries from Cursor: “If I change the response schema of the account summary API, what other systems in the repository depend on it?” EA GraphLink returns the dependency map: downstream consumers, their criticality, and any documented interface contracts. She can assess impact before making the change, not after deployment when the breakage surfaces.
API Contract Queries
A systems engineer is implementing a consumer of an existing service. She queries from Claude Code: “What is the documented interface specification for the product catalogue service?” EA GraphLink returns the interface specification from the repository: not from memory, not from a potentially outdated Confluence page, but from the authoritative architecture record. Implementation is grounded in the current specification.
Requirements Traceability During Development
A technical architect is reviewing a component implementation and wants to verify requirements coverage. She queries from Cursor: “What requirements in the repository trace to the order management application component?” EA GraphLink returns the requirement-to-component traceability from the repository. Coverage gaps are visible during development, not surfaced at a requirements review cycle that happens weeks later.
Standards Compliance During Design
An engineer is proposing a new technology for a component. Before proposing it to the architecture team, she queries from Cursor: “Is this database technology on our approved technology list, and are there any architectural constraints documented for its use?” EA GraphLink returns the technology standard classification from the repository. The conversation with the architecture team starts with informed context on both sides.
| Role | Primary Benefit | Secondary Benefit |
|---|---|---|
| Systems Engineer | Architecture context in their native environment: no context switching | Approved interfaces and dependency maps at query time |
| Technical Architect | Architecture reasoning during design, not only during review | Trade-off analysis grounded in live dependency data |
| MBSE Architect | Requirements and interface queries from repository during modeling | Gap identification against architecture without manual model review |
| Software Architect | Dependency and interface reference without leaving the IDE | Architecture-aware code generation grounded in approved patterns |
| Business Stakeholder | Low value: Copilot or Agentforce serve them better | (These personas should use ecosystem-embedded tools) |
| Pure EA Architect | Low value: Kernaro Assist or Claude serve them better | (IDE-embedded tools are not their native workflow) |
This integration reaches people that no other integration reaches: delivery engineers.
Every other EA integration in this guide targets business stakeholders, executives, or architecture architects using business and productivity platforms. None of them reaches the people doing delivery work in IDEs. Cursor and Claude Code integration is the only path to giving engineers live architecture context in the environment where they make technical decisions.
Architecture governance shifts from retrospective to continuous. When architecture information is available at design time, architectural alignment becomes a natural part of design: not a retrofit applied during review. Engineers who know what the approved interfaces are will use them. Engineers who can see what depends on an API before they modify it will be more careful. The repository becomes a working reference, not an artifact consulted in formal reviews and ignored between them.
The repository becomes relevant to people who previously ignored it. A software engineer with no EA client license, no access to the architecture portal, and no scheduled architecture review in the next three weeks has had no practical way to consult the EA repository. Cursor and Claude Code integration changes that. The repository is now accessible to anyone in the IDE with appropriate permissions. The reach of the architecture practice extends into the delivery organization without adding headcount.
No EA client license required for engineers. EA client licenses are expensive and typically scoped to the architecture team. Delivery engineers who need architecture context to do their jobs well cannot currently access it without either a license or a human architect as intermediary. MCP integration via Cursor or Claude Code makes the repository accessible to engineers within the tools they already use, without requiring EA client licenses per engineer.
This is primarily a technical persona integration: it will not address stakeholder self-service needs. If the priority is making architecture visible to business stakeholders, executives, and non-technical decision-makers, Copilot or Agentforce is the right integration. Cursor and Claude Code reach engineers and technical architects. Different audience, different value.
Governance clarity is required before rollout. Engineers querying the EA repository raises questions: What can they query? How much should they trust the answers? Who is responsible for answer quality when an engineer acts on incorrect repository data? These governance questions need answers before rollout: not after the first incident. Define the scope of queries, the expected quality standards, and the appropriate level of reliance on Claude Code responses versus architect review.
Adoption requires workflow behavior change. Engineers need to actively query EA GraphLink during their work rather than proceeding without architecture context. This is a behavior change. Some engineers will adopt it naturally when the value is apparent. Others will need to understand what they can ask and why it matters. Plan adoption support alongside technical deployment.
Less value if the repository is primarily strategic or motivation architecture. This integration is most valuable when the repository contains substantial application-layer and technology-layer content: components, interfaces, dependencies, technology standards. If the repository is primarily motivation architecture (goals, principles, strategy) with limited application and technology detail, engineers will find fewer practically useful answers. The value scales with the operational depth of the repository content.
Data governance: what engineers can access matters. Engineers with Cursor access to EA GraphLink may be able to query sensitive infrastructure patterns, security architecture, or commercially sensitive capability models. Configure the MCP connector’s access scope to expose appropriate content to this audience. Not all architecture data is appropriate for the engineering community without restriction.
EA GraphLink with MCP Server enabled. The MCP interface is how Cursor and Claude Code connect to the EA repository. Confirm your EA GraphLink deployment includes an active MCP Server endpoint with your Sparx Systems account manager.
Cursor and/or Claude Code with MCP configuration. Both tools support MCP tool connections via their configuration files. The EA GraphLink MCP Server is registered as a tool available to the AI assistant. This is a one-time configuration per developer environment: or deployed as a shared team configuration.
Engineering team access and permission scoping. Define which engineering teams and which individuals will have Cursor/Claude Code access to EA GraphLink. Configure access scope to expose appropriate repository content. Not every engineer needs access to every element: scope access to relevant application and technology domains.
MDG Technology quality: especially application and technology layers. EA GraphLink transforms the physical repository schema using the MDG Technology definition. For engineering use cases, the quality of application component definitions, interface specifications, and technology standard classifications is particularly critical. These are the elements engineers query. Incomplete or inconsistent MDG definitions for application and technology content will produce incomplete and inconsistent answers. MDG readiness is assessed in Discover and established in Deploy.
Governance policy for engineer use of repository queries. Document the expected use cases, the scope of appropriate reliance on Claude Code responses, and the escalation path for queries that return ambiguous or concerning results. Engineers should understand that Claude Code responses from the repository are a starting point for design conversation: not a substitute for architecture review on significant decisions.
Context-switching time is the primary efficiency metric.
Every time an engineer leaves the IDE to find architecture information: opening a browser, navigating to a portal, messaging an architect, waiting for a response: there is a context-switching cost. Research on developer productivity consistently finds context switching costs 15–30 minutes per interruption in terms of cognitive refocusing time, independent of the time spent on the interruption itself.
Formula:
Context-switching events per engineer per week
(times they leave the IDE to find architecture information)
× (time to retrieve information + context refocus time)
× engineering team size
× weeks per year
× engineering hourly rate
= annual context-switching overhead
MCP integration eliminates context switching for a subset of architecture queries.
Conservative reduction estimate: 50–70% of architecture lookups
Post-review rework avoided:
Architecture review cycles per year
× rework items per cycle caused by information-absence decisions
× hours to rework per item
× engineering hourly rate
= annual rework cost partially avoided
Example:
Context switching:
2 architecture lookups per engineer per day × 30 minutes per lookup
× 20 engineers × 48 weeks × $120/hour
= $576,000 annual overhead
At 60% reduction from MCP integration:
$576,000 × 60% = $345,600 annual value
Plus rework avoided:
4 review cycles/year × 5 rework items each × 8 hours/item × $120/hour = $19,200
Total: ~$365,000 for a 20-person engineering team
Scale this to your actual engineering team size and lookup frequency. The context-switching math produces large numbers because it applies to every engineer, every day. Even conservative estimates for large engineering teams exceed the cost of EA GraphLink and Connect engagement by a significant margin.
Kernaro AI Hub
Kernaro provides browser-based conversational access to the EA repository. It can serve similar architectural queries: available without IDE integration. Pros: browser-based, accessible to non-engineers (stakeholders can query the same data), no IDE-specific configuration. Cons: not integrated into IDE workflows: engineers must leave the development environment to use it. Kernaro is the right tool for stakeholder and architect access via browser; Cursor and Claude Code is the right integration for engineers who need context inside their IDE.
Prolaborate (Browser-Based EA Reporting)
Prolaborate provides self-service dashboards and portal access to EA data. Pros: lower cost, no AI licensing, readable architecture diagrams and reports. Cons: not conversational, not integrated into the IDE, requires portal navigation that represents the same context switch problem as consulting Confluence or SharePoint. Prolaborate is a good complement for structured reporting; it does not address IDE-embedded context.
Direct EA Repository Access via EA Client
Engineers with EA client licenses can access the repository directly. Pros: full repository access, familiar to EA architects. Cons: expensive license per user, steep learning curve for non-architects, and fundamentally changes the workflow: engineers in EA are not engineers in Cursor. The EA client is the right tool for architects doing EA work, not for engineers seeking architecture context during software development.
Architecture Documentation Exports (Confluence, SharePoint, etc.)
Periodic exports from the EA repository to static documentation in collaboration platforms. Pros: no integration required, readable by anyone. Cons: always out of date. The fundamental problem with static documentation exports is that they are snapshots: by the time an engineer reads an architecture document in Confluence, the repository may have been updated. Live repository queries via EA GraphLink are always current.
Q: What is the difference between Cursor and Claude Code for EA integration?
A: Both are AI-assisted development tools that support MCP connections to EA GraphLink: the integration mechanism and protocol are identical. The difference is their design focus and environment. Cursor is a full IDE (built on VS Code) with AI integrated throughout the development workflow. Claude Code is Anthropic’s terminal-based coding assistant, focused on command-line and agentic coding tasks. Both can connect to EA GraphLink’s MCP Server. The choice between them depends on how your engineering team works: IDE-first or terminal/command-line-first. Many technical architects will use both in different contexts.
Q: Do engineers need an EA license to query the repository via Cursor or Claude Code?
A: No. EA GraphLink’s MCP Server provides a query interface that does not require an EA client license. Engineers query the repository through EA GraphLink, which mediates all access. An EA client license is required only for people who need to author or edit the repository: the architecture team. Engineers querying for reference information do not need a license. This is one of the significant advantages of EA GraphLink integration: architecture context can reach the engineering community at scale without per-user EA licensing costs.
Q: What kind of architecture questions can engineers ask from within their IDE?
A: Any question that can be answered from the repository content EA GraphLink exposes. Practically: approved interfaces for a component or service, systems that depend on a given API or component, requirements that trace to a specific element, technology standard classifications, application component inventory for a business domain, lifecycle status of a technology or application, and architectural constraints documented for specific patterns. The scope of useful questions scales with the depth of the application and technology layer content in the repository.
Q: Can Claude Code write elements back to the EA repository?
A: No. EA GraphLink’s MCP Server is a read interface. Claude Code in Cursor can query and reason over repository content but cannot create, modify, or delete elements. All output remains external to the repository. If an engineer designs a new component and wants to add it to the repository, that requires manual action by an authorized architect in the EA client. This is the correct design: the repository is an authoritative record governed by the architecture practice, not modifiable by arbitrary tool integrations.
Q: How does MDG quality affect the usefulness of IDE integration?
A: Significantly. EA GraphLink transforms the physical EA repository schema using the MDG Technology definition. For IDE integration use cases, the most critical MDG quality dimensions are: application component definitions (are components well-defined and consistently named?), interface specifications (are interfaces documented with enough detail to be useful?), dependency relationships (are component-to-component dependencies modeled?), and technology standard classifications (are technologies classified against your standards taxonomy?). Poor quality in any of these areas means engineers receive incomplete or unreliable answers to the questions they most need to ask. MDG readiness is assessed in Discover and established in Deploy. Engineering community exposure of repository quality issues is fast and visible: plan MDG quality work before activating this integration.
Q: Is this integration suitable for regulated industries with data governance requirements?
A: Cursor and Claude Code process queries using cloud AI services: Claude Code uses Anthropic’s API, Cursor uses its own AI infrastructure. Architecture repository data flows from EA GraphLink to these cloud services for query processing. This is the same governance consideration as the Claude integration guide. Regulated industries should review whether repository content: particularly if it includes security patterns, infrastructure specifications, or commercially sensitive capability models: is appropriate for cloud AI processing. Scope the EA GraphLink access permissions to expose only content appropriate for engineering audience queries in your governance context.
Q: What is the setup process for adding EA GraphLink MCP to Cursor?
A: EA GraphLink provides an MCP Server endpoint and authentication credentials. In Cursor, MCP servers are configured in the ~/.cursor/mcp.json configuration file by specifying the EA GraphLink server URL and credentials. Once configured, EA GraphLink appears as a set of available tools within Cursor’s Claude integration, accessible during any session. For team deployment, this configuration can be distributed as a standard team setup rather than configured per-individual. Sparx Services configures the EA GraphLink MCP Server endpoint during Connect. Your engineering team configures the Cursor MCP client connection.
Q: Can we limit what parts of the repository engineers can query?
A: Yes. EA GraphLink’s MCP Server configuration controls the scope of content exposed through the interface. You can restrict access to specific packages, domains, element types, or relationship types. For example: expose application components and interfaces in engineering-relevant domains, but exclude security architecture patterns or executive-level strategic content. Access scope is a governance decision made during Connect configuration. Define which engineering teams need access to which repository domains, and configure accordingly. Access can be refined over time as patterns of use become clear.
Cursor and Claude Code integration reaches the audience that every other EA integration misses: the engineers and technical architects who are translating architecture decisions into built systems. When those people have live architecture context in their IDE, architecture becomes a working reference rather than a periodic artifact.
The journey starts with assessing your repository foundation: specifically, the depth and quality of your application and technology layer content, and MDG quality for engineering-relevant elements. If you haven’t completed a Discover assessment, that’s the right first step.
If you’re ready to connect your EA repository to your engineering environment:
[Start Your Connect Engagement]
Questions about reaching the engineering community with architecture context?
[Let’s Discuss Your Integration Strategy]
Talk to a Sparx Services architect about where your organization is on the journey and what the next stage looks like.