Beyond Entity MCP Usage Guide

What You Can Do with Beyond Entity MCP

Beyond Entity MCP lets AI tools read and work with your Beyond Entity projects, including data models, entities, attributes, relationships, processors, data flows, and change history.

You can ask from MCP-capable AI tools such as Claude, ChatGPT, Cursor, and VSCode using natural language. The AI can inspect your project structure through Beyond Entity MCP, perform modeling tasks, compare changes, and prepare documentation.

Examples of work you can delegate:

  • Analyze an existing database schema and explain entities and relationships
  • Design or add new tables, columns, constraints, and relationships
  • Model processors such as APIs, batch jobs, ETL flows, and data synchronization
  • Document data flows and transformations from SQL or processing logic
  • Find personal data, sensitive data, and encryption candidates
  • Compare model changes between branches or commits
  • Use models created in the webapp for AI code generation, reviews, and documentation
  • Generate SQL, DDL, and migration drafts from Beyond Entity schemas
  • Extract design documents from existing code
  • Review whether current code follows the design defined in Beyond Entity

What Is MCP?

MCP, or Model Context Protocol, is a standard way for AI tools to safely read data from external systems and perform actions.

Typical AI chat can only use the information a user pastes into the conversation. With Beyond Entity MCP connected, the AI can directly inspect Beyond Entity projects within the user's permissions. This allows the AI to answer and work based on the latest model structure, attribute definitions, relationships, processors, data flows, and change history.

Who Should Use It

Beyond Entity MCP is useful for:

  • Data modelers who want to design and review ERDs, tables, columns, keys, and relationships
  • Backend developers who want API, DTO, ORM entity, and migration drafts based on data models
  • Data engineers who want to model and document ETL, ELT, batch, streaming, and data sync flows
  • Security and governance teams who need to explore PII, sensitive data, encryption targets, and lineage
  • Project leads who need to review model changes across branches, commits, and releases
  • Architects and reviewers who need to compare implementation code against design, or extract missing design information from code

Common Job Types

1. Project Exploration

Ask the AI to summarize the overall project structure.

Possible tasks:

  • List accessible projects
  • Select a project
  • Summarize canvases, models, entities, and processors
  • Search model elements by name or keyword
  • Check the current branch and change status

Example prompts:

Show me the Beyond Entity projects I can access.

Summarize this project's data models and API processors so I can understand them at a glance.

Find and summarize entities, attributes, and processors related to customer.

2. Reading and Documenting Data Models

The AI can read models, entities, attributes, constraints, and relationships, then turn them into human-readable documentation.

Possible tasks:

  • Explain the columns and purpose of a specific entity
  • Summarize primary keys, foreign keys, indexes, and constraints
  • Explain relationships between entities
  • Draft a data dictionary based on business terminology
  • Review table design

Example prompts:

Document the columns, keys, and relationships of the Order entity.

Explain the relationships between member, order, and payment tables for non-developers.

Find columns in this model that appear to have similar names or duplicate meanings.

3. Database Model Design

Ask the AI to create a new data model or add entities, attributes, constraints, and relationships to an existing model.

Possible tasks:

  • Create models for MySQL, PostgreSQL, Oracle, SQL Server, BigQuery, Snowflake, and other storage types
  • Design new tables and columns
  • Add primary keys, foreign keys, check constraints, and indexes
  • Create relationships
  • Add attributes to existing entities
  • Rename models, tables, and columns

Example prompts:

Design a data model for a subscription billing feature. It needs customer, subscription, payment method, invoice, and payment attempt tables.

Add SKU, sales status, sales start date, and sales end date columns to the Product entity.

Create a relationship where one Order can have multiple Payment attempts.

4. API, Batch, and ETL Process Modeling

Beyond Entity MCP can handle not only database tables, but also processors such as API servers, ETL batches, ELT jobs, stream processing, file processors, and data sync flows.

Possible tasks:

  • Model API request and response structures
  • Define batch inputs, intermediate lookup values, and outputs
  • Add SQL-based extraction and transformation logic
  • Document read, write, and transform relationships between processors and data entities
  • Summarize multi-step processing flows

Example prompts:

Model the admin login API as a processor. Inputs are email and password. Outputs are accessToken and user information.

Design a daily batch processor that aggregates order data and writes it to daily_sales_summary.

Register the data flow for this SQL by identifying which tables it reads and which output fields it creates.

5. Data Lineage and Impact Analysis

The AI can trace data flows between attributes, entities, and processors to explain impact.

Possible tasks:

  • Trace where a specific column is read and written
  • Identify which DB column feeds an API response field
  • Summarize batch or ETL inputs and outputs
  • Find processors affected by a column change
  • Document data flows

Example prompts:

Find where the customer_email column is used in API responses or batch outputs.

Summarize processors that may be affected if Payment.status changes.

Explain the main data flow from member registration to order creation.

6. PII and Sensitive Data Discovery

You can inspect personal data, sensitive data, and encryption targets across the project.

Possible tasks:

  • Search attributes with PII levels
  • Check encryption or masking candidates
  • List columns by sensitivity level
  • Identify entities and processors containing personal data
  • Prepare a security review summary

Example prompts:

Find all attributes marked as personal data in this project.

Review columns that look like they need encryption but do not have encryption settings yet.

Summarize where user-identifying data is exposed in API responses.

7. Change and Version Comparison

Beyond Entity projects use a Git-based collaboration workflow. Through MCP, the AI can inspect and summarize changes between branches and commits.

Possible tasks:

  • Check uncommitted workspace changes
  • Compare branches
  • Compare commits
  • Review commit history
  • Draft model change review notes

Example prompts:

Summarize model elements changed on the current branch.

Explain the difference between the main branch and the current branch from a data model perspective.

Prepare review notes for entities and attributes changed in the latest commit.

8. SQL, DDL, Code Generation, and Development Support

The AI can read Beyond Entity model structures and generate drafts needed for database and application development.

Possible tasks:

  • Generate SQL DDL from Beyond Entity schemas
  • Write CREATE TABLE, column addition, index, and constraint SQL
  • Draft database migrations
  • Write query, validation, and inspection SQL
  • Draft ORM entity classes
  • Generate API DTO, request, and response types
  • Suggest test data structures
  • Review API design against the model

Example prompts:

Generate MySQL DDL based on the current Beyond Entity model.

Create a PostgreSQL migration SQL draft for only the newly added entities and attributes.

Write CREATE TABLE statements for Order, Payment, and Refund, including primary keys, foreign keys, and indexes.

Draft JPA entities based on the Customer and Order entities.

Create FastAPI request and response Pydantic models based on this processor definition.

Create data validation SQL that can be used before production deployment based on the Beyond Entity schema.

9. Extracting Design Documents from Existing Code

When used together with a code repository, the AI can extract data model, API, batch, and processor design documents from already implemented code.

Possible tasks:

  • Extract table and column structures from ORM entities, SQL, and migration files
  • Summarize API requests, responses, and related tables from controllers, routers, and services
  • Document inputs, processing, and outputs from batch, ETL, and scheduler code
  • Identify model elements that exist only in code as candidates for Beyond Entity design updates
  • Draft an initial data dictionary or system design document from the implementation

Example prompts:

Analyze the ORM entities and migration files in the current codebase and draft a data model design document.

Summarize request, response, and used tables for the user management APIs based on router and service code.

Extract which tables the batch code reads and writes, and turn them into processor design candidates.

10. Comparing Current Code with the Design

You can compare the design defined in Beyond Entity with the actual implementation and identify mismatches or missing items.

Possible tasks:

  • Check whether code tables, columns, types, and constraints match the Beyond Entity model
  • Review whether API request and response structures match processor design
  • Find entities, attributes, or APIs that exist in code but not in the design
  • Find items defined in the design but not implemented in code
  • Summarize mismatches in column names, types, nullability, enum values, and relationships
  • Review whether code changes and design changes were both reflected

Example prompts:

Compare the User ORM model in the current code with the User entity design in Beyond Entity.

Review whether the order creation API implementation matches the processor input, output, and data flow defined in Beyond Entity.

Find tables, columns, and APIs that exist in code but are not registered in the Beyond Entity design.

List items that exist in the Beyond Entity model but cannot be found in the current code.

MCP Connection Information and API Key Issuance

To use Beyond Entity MCP, you need an MCP server URL and an API key.

The MCP server URL can differ by user or organization because it depends on the cell server. Do not copy another user's MCP URL directly. Check the MCP URL shown in your own Beyond Entity webapp.

Where to check and issue keys:

  1. Sign in to the Beyond Entity webapp.
  2. Go to Settings.
  3. Open AI MCP Key.
  4. Check the MCP server URL displayed on the screen.
  5. Create an API key for AI tool access.
  6. Register the MCP server URL and API key in your MCP-capable AI tool.

AI tool settings usually require:

  • MCP server URL: the URL shown on the AI MCP Key screen
  • Authentication header: X-API-Key
  • API key value: the key generated from the AI MCP Key screen

The Settings > AI MCP Key screen can render the connection guide Markdown returned by the server. The guide includes actual MCP URLs based on the user's organization cell server.

The MCP Server URLs are generally provided in two forms.

Recommended:

Streamable HTTP
https://{cell-server}/mcp

Legacy / Compatibility:

SSE
https://{cell-server}/sse

Most modern MCP clients should use Streamable HTTP. Use SSE only when your AI tool does not support Streamable HTTP or explicitly asks for an SSE endpoint.

Direct Checkout Mode for a specific project can use these forms:

Streamable HTTP
https://{cell-server}/mcp?project_id={PROJECT_ID}

SSE
https://{cell-server}/sse?project_id={PROJECT_ID}

Security notes:

  • MCP server URLs can differ by environment, so URLs in examples are only references.
  • Treat API keys like passwords. Do not put them in public repositories or shared documents.
  • If a key is lost or exposed, revoke it and issue a new one.
  • Operations performed with the API key follow the user's permissions.

Example configuration:

{
  "mcpServers": {
    "beyond-entity": {
      "url": "MCP server URL shown on the AI MCP Key screen",
      "headers": {
        "X-API-Key": "issued API key"
      }
    }
  }
}

Connection Modes

Beyond Entity MCP supports two connection modes.

If you are not sure which transport to choose, start with Streamable HTTP. SSE is provided for compatibility with existing MCP clients.

Interactive Mode

Use this mode when you want to explore multiple projects or switch projects during a conversation.

Best for:

  • Chat-style AI tools such as Claude, ChatGPT, and Gemini
  • Exploring multiple projects in one conversation
  • When you do not know the project ID in advance
  • When you want the AI to list projects and let you choose one

Basic flow:

  1. Connect to the MCP server.
  2. The AI lists projects you can access.
  3. You select a project.
  4. The AI checks out the project and starts working.
  5. Switch to another project if needed.

Direct Checkout Mode

Use this mode when one IDE workspace should be fixed to one Beyond Entity project.

Best for:

  • IDEs such as VSCode and Cursor
  • One workspace corresponding to one project
  • Starting work without selecting a project every time
  • When you already know the project ID

Basic flow:

  1. Add project_id to the MCP connection URL.
  2. Beyond Entity automatically checks out the project on the first tool call.
  3. All subsequent work runs in that project context.

Permissions and Security

Beyond Entity MCP works based on the user's API key and project permissions.

  • Users can only access projects they are permitted to access.
  • Read-only users cannot perform write operations.
  • Project, branch, and canvas permissions are enforced.
  • MCP operations run within Beyond Entity's collaboration and change management workflow.
  • For the same user and project, webapp, MCP, and IDE sessions can share the same remote workspace.

Notes:

  • Branch changes in one session can affect other sessions for the same project.
  • Before important structural changes, check the current branch and change status.
  • Request delete operations carefully, considering review and recovery steps.

Recommended First Workflow

For first-time users, use this flow:

  1. "Show me my project list."
  2. "Select this project."
  3. "Summarize the full model structure."
  4. "Find the important entities and processors."
  5. "Analyze the impact of the change I want to make."
  6. "Compare whether the current code matches the design."
  7. "Create the proposed changes."
  8. "Summarize the changes as review notes."

Writing Good Prompts

When asking the AI, include the target, expected output, and constraints.

Good prompt examples:

Find the core entities in the order domain and summarize each entity's purpose, key columns, and relationships in a table.

I want to add a subscription billing feature. Check the existing customer and payment models first, then propose new entities and relationships. Show the design first before making changes.

Find columns that look like personal data, such as email, phone, and address, and check whether PII settings are applied. Mark missing candidates separately.

Compare the current branch with main and summarize only the data model changes reviewers should inspect.

Check the API implementation in the code repository first, then list only the differences from the processor design defined in Beyond Entity.

Copy-Paste Prompt Examples

You can paste these prompts directly into your AI tool.

Summarize this project's full data structure as if explaining it to someone seeing it for the first time.

Find member-related tables and API processors, then summarize what data moves between them.

Find reference columns that appear to be missing foreign key relationships in this model.

Design a data model for a new coupon feature and add it to Beyond Entity.

Summarize recently changed entities, attributes, and relationships in release note format.

Find columns containing personal data and the processors that use those columns, then create a security review checklist.

Analyze this SQL query and summarize its inputs, lookups, and outputs as processor transformations.

Suggest API DTOs that backend developers need to implement based on the current model.

Create SQL DDL and migration drafts based on the current Beyond Entity schema.

Generate PostgreSQL CREATE TABLE statements including designed foreign key relationships and indexes.

Extract a data model design document from the existing code and list candidates to reflect in the Beyond Entity model.

Find places where the current code differs from the Beyond Entity design and group them by severity.

Usage Notes

Beyond Entity MCP helps AI understand and work with your project more accurately, but it does not replace human review.

  • Review AI-created designs against your team's modeling rules and business standards.
  • For large changes or delete operations, inspect the proposed changes before applying them.
  • Adjust generated code for your actual framework, version, and naming conventions.
  • Review security, privacy, and permission decisions against your organization's policy.

Summary

Beyond Entity MCP connects AI tools to the actual models and change history in Beyond Entity, enabling data modeling, process design, lineage analysis, security review, SQL and code generation, code-to-design extraction, and design compliance review.