JedIN Platform Architecture — Integration, R2-CX, and MCP Ecosystem
Three Products, One Platform
JedIN is not a single tool. It is a platform built from three interconnected products that serve different roles in the enterprise integration lifecycle. The Integration product handles flow design, deployment, and monitoring. R2-CX provides AI-driven autonomous access to enterprise systems. The MCP Ecosystem supplies the 152 tools that power both products under the hood.
This post explains how each product works, what it contains, and how the three connect to form a coherent platform. It is written for architects, technical leads, and decision-makers evaluating the platform — not as a step-by-step guide, but as a map of the territory.
Prerequisites
To get the most from this overview, you should have:
- Basic familiarity with iPaaS concepts — integration flows, connectors, message transformation, deployment
- Understanding of API-driven architectures — REST APIs, OAuth2, JSON payloads
- Awareness of SAP Cloud for Customer (C4C) and SAP Cloud Integration (CPI) concepts — helpful but not required
- Access to a JedIN tenant — recommended if you want to verify the architecture against a live instance, but this post is self-contained
Product 1: JedIN Integration
The Integration product is the core iPaaS. It provides four main surfaces:
Flow Designer
The Flow Designer is a visual canvas built on ReactFlow where integration flows are created, configured, and managed. Each flow is a directed graph of nodes (processing steps) connected by edges (execution paths).
Key characteristics:
- 12-category node palette — covering Participants, Events, Process, Call, Message Routing, Message Transformers, Persistence, Security, Encoder, Validator, SAP Adapters, and Connectors
- 8-tab properties panel — General, Runtime Configuration, Error Configuration, References, Externalized Parameters, Problems, Deployment Status, and Design Guidelines
- Swimlane layout — nodes are organized inside Sender, Integration Process, and Receiver swimlanes, mirroring the SAP CPI visual model
- One-click deploy — flows are compiled from the visual representation to Camel K YAML and deployed to the runtime engine directly from the toolbar
The designer currently supports all node types from the SAP CPI palette (84/84 components at 100% parity), making it possible to import existing SAP CPI flows and edit them visually.
Design Page
The Design page is the package management layer. It holds 101+ packages, each containing one or more artifacts:
| Artifact Type | Description |
|---|---|
| iflow | Integration flows — the primary artifact type, opened in the Flow Designer |
| valuemapping | Key-value lookup tables used during message transformation |
| scriptcollection | Groovy or JavaScript script libraries shared across flows |
| messagemapping | Visual field-to-field mapping definitions |
Packages are organized by vendor, domain, or project. The 101 pre-loaded packages cover SAP-to-SAP replication, third-party CRM synchronization, e-commerce integrations, and utility patterns. Each package tracks version history and deployment status independently.
Monitoring
The Monitoring surface provides real-time and historical visibility into flow execution:
- Real-time dashboard — live execution status, active flows, current throughput (messages/second)
- 30-day history — execution counts, success/failure rates, average latency, and error distribution by flow
- Message trace — drill into individual executions to see the message payload at each node, headers, and properties
- Alert configuration — threshold-based alerts for failure rates, latency spikes, and queue depth
The monitoring backend aggregates metrics from the Camel K runtime and stores 30-day rolling history. Older data can be exported to ClickHouse for long-term analytics.
Marketplace
The Marketplace provides 15+ pre-built connector packages ready for installation:
- SAP connectors — IDoc, RFC, OData V2/V4, SuccessFactors, Ariba, S/4HANA
- Cloud connectors — Salesforce, HubSpot, Vtex, TOTVS Protheus
- Protocol connectors — HTTP/REST, SFTP, AMQP, Kafka, JDBC, AS2, Mail
- Utility packages — error handling patterns, logging frameworks, credential rotation templates
Each marketplace entry includes documentation, sample flows, and version compatibility information. Installing a package adds it to your Design page where you can customize it.
Product 2: R2-CX
R2-CX is the AI-powered autonomous consultant. It connects to enterprise systems through browser automation (Playwright) and API calls, executing real actions from natural language commands.
Multi-Product Hub
The R2-CX Hub at /r2cx shows all available target systems. Currently 14 systems are registered across three readiness tiers:
| Tier | Systems | Status |
|---|---|---|
| Production | SAP C4C, JedIN, SAP CPI | Fully tested, 152 tools validated |
| API-Ready | Power BI, Power Apps | Tools built, awaiting Azure AD tenant |
| Beta | Salesforce, HubSpot, Vtex, TOTVS, S/4HANA, ABAP, SAC, Emarsys, C4C v2 | Tools in development |
Each target system has its own MCP server providing specialized tools. Clicking a target system opens its dedicated workspace.
Workspace
The Workspace is the primary R2-CX interface. It consists of:
- Chat panel (left) — a conversational interface where you type natural language commands. R2-CX interprets your intent, selects the appropriate MCP tools, executes them, and returns structured results.
- Live View (right) — a real-time browser view showing the target system's screen. When R2-CX navigates SAP C4C, you see every click, form fill, and page load as it happens.
The AI layer supports multi-turn conversations with context retention. You can ask follow-up questions, refine previous commands, and chain operations across multiple systems in a single session.
Projects
R2-CX Projects provide long-running context for complex engagements:
- Documents — attach requirements, specifications, and reference materials
- Tasks — track implementation progress with status and priority
- Sessions — all chat sessions linked to the project for audit trail
- Settings — project-specific configuration (target systems, credentials, AI parameters)
Projects are designed for SAP implementation scenarios where a consultant works across multiple sessions over days or weeks, building up context progressively.
Sessions
Every R2-CX interaction is recorded as a session. Sessions capture:
- Full chat history with timestamps
- Every MCP tool call with parameters and results
- Screenshots taken during browser automation
- Errors, retries, and recovery actions
Sessions can be reviewed for audit purposes, used as training data for improving AI responses, or exported as documentation of work performed.
Skills and Docs
R2-CX includes 17 pre-built skills and a documentation library:
- Skills — reusable prompt templates for common tasks (e.g., "Create REST Integration", "Run Full Audit", "Generate ABSL Validation Code")
- Docs — reference documentation for each target system, accessible from within the workspace
- APIs — endpoint documentation for programmatic access to R2-CX capabilities
Product 3: MCP Ecosystem
The MCP (Model Context Protocol) Ecosystem is the tool layer that powers both Integration and R2-CX. It consists of three production MCP servers providing 152 validated tools:
MCP C4C — 26 Tools
The SAP C4C MCP server uses Playwright browser automation exclusively (no external OData API access). Tools include:
| Category | Tools | Examples |
|---|---|---|
| Navigation | 4 | c4c_login, c4c_navigate, c4c_screenshot, c4c_evaluate |
| Data | 6 | c4c_count, c4c_search, c4c_read_entity, c4c_list_entities |
| Configuration | 5 | c4c_fine_tuning, c4c_adaptation_mode, c4c_list_code_lists |
| Analysis | 3 | c4c_analyze (4 types), c4c_generate_absl, c4c_test_environment |
| Session | 4 | c4c_start_session, c4c_end_session, c4c_get_status, c4c_recover |
| KUT/Extension | 4 | c4c_create_field, c4c_list_fields, c4c_create_extension, c4c_deploy_extension |
All data access occurs through in-browser fetch() calls against OData endpoints, using the active session cookies. This approach works with tenants that do not expose external API access.
MCP JedIN — 79 Tools
The JedIN MCP server provides comprehensive platform management:
| Category | Tools | Examples |
|---|---|---|
| Flows | 15 | jedin_list_flows, jedin_create_flow, jedin_deploy_flow, jedin_execute_flow |
| Packages | 8 | jedin_list_packages, jedin_create_package, jedin_export_package |
| Monitoring | 10 | jedin_get_execution_metrics, jedin_get_health, jedin_get_message_trace |
| Credentials | 6 | jedin_list_credentials, jedin_create_credential, jedin_rotate_credential |
| Tenant | 5 | jedin_get_tenant_info, jedin_get_tier_limits, jedin_get_usage |
| Code Assist | 15 | jedin_get_node_types (210 types), jedin_get_templates (10), jedin_get_connector_patterns (15) |
| Skills | 11 | create_rest_integration, create_sap_integration, get_connector_info |
| CPI Bridge | 9 | jedin_import_cpi_package, jedin_export_iflow, jedin_convert_cpi_flow |
The JedIN MCP server communicates with the platform API using the same REST endpoints available to the web frontend, authenticated via access tokens.
MCP CPI — 47 Tools
The SAP CPI MCP server provides parity with SAP Cloud Integration operations:
| Category | Tools | Examples |
|---|---|---|
| Packages | 8 | cpi_list_packages, cpi_create_package, cpi_download_package |
| Artifacts | 10 | cpi_list_artifacts, cpi_deploy_artifact, cpi_get_artifact_content |
| Monitoring | 8 | cpi_get_message_processing_logs, cpi_get_integration_content |
| Configuration | 6 | cpi_get_externalized_parameters, cpi_update_configuration |
| Security | 5 | cpi_list_security_materials, cpi_deploy_certificate |
| Design | 10 | cpi_get_resources, cpi_update_resource, cpi_get_configurations |
How the Products Connect
The three products form a feedback loop:
Natural Language Commands
|
v
+------+------+
| R2-CX |
| (AI Layer) |
+------+------+
|
+------------+------------+
| | |
v v v
+---------+ +---------+ +---------+
| MCP C4C | | MCP | | MCP CPI |
| 26 tools| | JedIN | | 47 tools|
| | | 79 tools| | |
+---------+ +---------+ +---------+
| | |
v v v
+---------+ +---------+ +---------+
| SAP C4C | | JedIN | | SAP CPI |
| (Browser)| | (API) | | (API) |
+---------+ +---------+ +---------+
Typical cross-system workflow:
- A user opens R2-CX and types: "Check how many accounts exist in C4C and verify the account replication flow is deployed in JedIN"
- R2-CX calls
c4c_count(CorporateAccountCollection) andjedin_list_flows(filtering for replication flows) - The AI correlates the results: 847 accounts in C4C, the replication flow is deployed and ran 23 times in the last 24 hours with 100% success
- R2-CX reports: "847 accounts in C4C. The 'Business Partner Replication' flow is deployed and healthy — 23 executions, zero failures."
This loop works because R2-CX has simultaneous access to both systems through their respective MCP servers. No manual switching between consoles is required.
Auto-Recovery and Resilience
Production sessions encounter interruptions. R2-CX handles these automatically:
| Scenario | Recovery Mechanism |
|---|---|
| SAP C4C session expires | Auto-login using stored credentials. The c4c_recover tool detects session death and re-authenticates within 3 retries. |
| JedIN token expires | Automatic token refresh using the refresh token flow. Transparent to the user. |
| Browser crash | New Playwright browser instance launched, session state restored from checkpoint. |
| ABSL generation defaults | When generating ABSL code, missing parameters are filled with safe defaults (e.g., standard BO types, default namespaces). |
| MCP tool timeout | Automatic retry with exponential backoff (1s, 2s, 4s). After 3 failures, R2-CX reports the error and suggests manual intervention. |
Validated Results
The platform has been stress-tested with the following outcomes:
| Metric | Result |
|---|---|
| MCP tools validated | 152 across 3 servers (26 + 79 + 47) |
| Skills available | 17 reusable prompt templates |
| Test scenarios passed | 61/61 (E2E benchmark, Grade A+) |
| Wiki posts generated | 33 (cross-system documentation) |
| MDX content files | 99+ across 3 locales |
| Video walkthroughs | 9 recorded demonstrations |
| Stress test | 100% pass rate under sustained load |
| Production Readiness Score | 95.6 — CERTIFIED |
| Speedup vs. manual | 14.1x faster than traditional consultant workflow |
Summary
JedIN's architecture separates concerns cleanly: the Integration product handles the build-deploy-monitor lifecycle, R2-CX provides AI-driven autonomous operations, and the MCP Ecosystem supplies the tool layer connecting everything to real enterprise systems.
The three products share a common backend (NestJS API, PostgreSQL, Redis) and authentication layer. A user can design a flow in the Integration Flow Designer, switch to R2-CX to verify the target system's data, deploy the flow via natural language, and monitor execution — all within the same platform session.
For hands-on guides, see:
- Flow Designer Quick Start — opening and navigating your first flow
- Getting Started with R2-CX — your first autonomous session
- Cross-System Assessment — auditing C4C and JedIN together
- Data Quality Audit — running all four analysis types
Related Articles
JedIN Integration — Complete iPaaS Core Technology Stack
Technical deep dive into the core product of the JedIN platform: Next.js 14, NestJS 10, Prisma 5, Apache Camel K 2.9 + Quarkus + Java 21, KEDA auto-scaling, PostgreSQL 16 with multi-tenant RLS, Redis 7, MinIO, BullMQ, 30 MCPs and 307 tools.
145 Tools, 17 Skills, 3 Systems, One Session: Inside the MCP Ecosystem That Powers R2-CX
A technical deep-dive into the validated MCP ecosystem behind R2-CX, covering 145 production tools across SAP C4C, SAP CPI, and JedIN servers with real performance benchmarks, auto-login recovery, and the full tool inventory.
Real-Time Platform Health Monitoring: 7 JedIN Tools in 425ms
R2-CX queried the entire JedIN platform health in under half a second — flows, packages, connections, nodes, and system health in a single AI session.