MCP serverMCP servertypeExposes tools to a coding agent over MCP.See every one →What this type is →independently maintainedindependently maintainedoriginPublished by one person or a small company outside SAP. Says nothing about quality; the readings say that.See every one →

cap-mcp-bridge

Points at a running CAP or OData V4 service, reads its $metadata, and turns what it finds into MCP tools — list, describe, query with validated filters, expand, and invoke functions and actions.

It sits outside the service rather than inside it, so nothing in the CDS model has to be annotated and the target does not have to be CAP at all — any OData V4 endpoint that serves $metadata works. That is the trade against the plugins that generate a server from the model: no per-service code, but also no model-level control over what is exposed.

Facts

Latestv0.1.0ReleasedLast pushLicenceMIT

Where it sits

Lives in
Provides
Agent access to your systemsCAPAgent access to your systemscapabilityGiving an AI agent access to the business data, configuration or operations of systems you run through an MCP server. [Serving your application over MCP](capability:mcp-servers) exposes your own service contract; system access reaches the systems behind it, and one implementation may do both. Development assistance belongs to [agent access to your code](capability:agent-code-access).
Flavors
Node.jsfrom its runtime

Who is behind it

SanoberSanoberPersonMaintains this
In the atlas: maintains 1, contributes to 1
@SanoberRehman
maintainer

Before choosing this

Conditions

PolicySAP API Policy 4.2026a§ 1.1, 1.2, 2.2.2from Agent access to your systemsAn MCP server uses SAP APIs to supply tools, resources or data to an agent.
  • § 1.1 Published APIs. Published APIs are made available for the documented purposes identified by SAP, including integration, extensions and data exchange.
  • § 1.2 Non-Published APIs. Customer and third-party applications must not access non-published APIs except where documentation permits it or SAP otherwise authorizes it.
  • § 2.2.2 AI call sequences and data extraction. Outside SAP-endorsed architectures, data services or expressly identified pathways, the policy prohibits specified agentic API use and systematic or large-scale extraction.

MCP does not replace the API's documented-use boundary. Check that every endpoint is published for the intended use and whether the policy's AI-call or extraction provisions apply to the design.

SAP API Policy 4.2026a →
LicenceSAP Developer License Agreement 3.2 CAP§ 1, 3from Agent access to your systemsAn MCP server uses SAP APIs to supply tools, resources or data to an agent.
  • § 1 License. Productive customer applications are limited to SAP BTP or another SAP-licensed platform, and mass extraction to a non-SAP product is restricted except where solely required for SAP interoperability.
  • § 3 Artificial Intelligence Training. The agreement prohibits use of the covered materials and customer applications for training artificial-intelligence models or systems.

The CAP developer agreement can apply alongside the API Policy. Ordinary agent inference is not automatically AI training; section 3 becomes relevant when covered materials or applications are used to train, develop or refine a model or system.

SAP Developer License Agreement 3.2 CAP →

What it declares

Every artifact

Type
MCP server
Origin
Independently maintained
Runtime
Node.js

As an MCP server

Language
TypeScript

Tasks this contributes to6Beta

Access an external system through an application MCP serviceAn AI agent queries external system data or invokes selected external operations through an application-owned service contract exposed over MCP.Java, Node.js4 scopes
CAP JavaCovers, under conditions

Dated assessment history · last accepted 2026-10-12. Excluded from the current connected answer.

Expose the CAP application-owned service as a reachable OData V4 endpoint with $metadata; the CAP application still implements remote integration. Run cap-mcp-bridge as a separate Node.js process and configure its HTTP access and backend credentials; this process does not change the CAP application runtime. Read-only is the default. Write tools, including actions, require explicit writeEnabled/--write configuration and appropriate backend permissions. Retain backend authorization and validate the chosen target; the bridge does not supply the application service or its remote handlers.

All options on the Serve your application over MCP page →
CAP JavaAssessed, not known

Dated assessment history · last accepted 2026-10-12. Excluded from the current connected answer.

Expose the CAP application-owned service as a reachable OData V4 endpoint with $metadata; the CAP application still implements remote integration. Run cap-mcp-bridge as a separate Node.js process and configure its HTTP access and backend credentials; this process does not change the CAP application runtime. Read-only is the default. Write tools, including actions, require explicit writeEnabled/--write configuration and appropriate backend permissions. Retain backend authorization and validate the chosen target; the bridge does not supply the application service or its remote handlers. Assess the exact SAP target, published API use and architecture separately; the README's generic SAP endpoint claim is not permission or an endorsement.

All options on the Serve your application over MCP page →
CAP Node.jsCovers, under conditions

Dated assessment history · last accepted 2026-10-12. Excluded from the current connected answer.

Expose the CAP application-owned service as a reachable OData V4 endpoint with $metadata; the CAP application still implements remote integration. Run cap-mcp-bridge as a separate Node.js process and configure its HTTP access and backend credentials; this process does not change the CAP application runtime. Read-only is the default. Write tools, including actions, require explicit writeEnabled/--write configuration and appropriate backend permissions. Retain backend authorization and validate the chosen target; the bridge does not supply the application service or its remote handlers.

All options on the Serve your application over MCP page →
CAP Node.jsAssessed, not known

Dated assessment history · last accepted 2026-10-12. Excluded from the current connected answer.

Expose the CAP application-owned service as a reachable OData V4 endpoint with $metadata; the CAP application still implements remote integration. Run cap-mcp-bridge as a separate Node.js process and configure its HTTP access and backend credentials; this process does not change the CAP application runtime. Read-only is the default. Write tools, including actions, require explicit writeEnabled/--write configuration and appropriate backend permissions. Retain backend authorization and validate the chosen target; the bridge does not supply the application service or its remote handlers. Assess the exact SAP target, published API use and architecture separately; the README's generic SAP endpoint claim is not permission or an endorsement.

All options on the Serve your application over MCP page →
Change application records from an agentCreate or update application records through an MCP client.Node.jsCovers, under conditionsexternal OData bridge

Configure a reachable custom CAP/OData V4 service and its credentials; run the separate Node.js bridge process. Enable write mode and ensure the backend permits the selected operations.

All options on the Serve your application over MCP page →
Expose an application service to an AI agentLet an MCP client discover and query application data and invoke selected business operations.Node.jsCovers, under conditionsexternal OData bridge

Dated assessment history · last accepted 2026-10-12. Excluded from the current connected answer.

Configure a reachable custom CAP/OData V4 service and its credentials; run the separate Node.js bridge process. Enable write mode for action invocation.

All options on the Serve your application over MCP page →
Invoke a business operation from an agentInvoke a selected application business operation through an MCP tool.Node.jsCovers, under conditionsexternal OData bridge

Configure a reachable custom CAP/OData V4 service and its credentials; run the separate Node.js bridge process. Action invocation requires write mode to be enabled.

All options on the Serve your application over MCP page →
Provide application context as MCP resourcesLet an MCP client retrieve application data or schema context through resource URIs.Node.jsCovers, under conditionsschema resource server

Configure a reachable custom CAP/OData V4 service and its credentials; run the separate Node.js bridge process.

All options on the Serve your application over MCP page →
Query application data from an agentRetrieve selected application records through MCP without changing those records.Node.jsCovers, under conditionsexternal OData bridge

Configure a reachable custom CAP/OData V4 service and its credentials; run the separate Node.js bridge process.

All options on the Serve your application over MCP page →

Connections3

Install

npm add cap-mcp-bridge

Derived from the package name. No recipe recorded; the README has the configuration.

README

quoted from SanoberRehman/cap-mcp-bridge under MIT, read
SanoberRehman/cap-mcp-bridge/README.mdOn GitHub

cap-mcp-bridge

npm CI node license

Point it at any SAP CAP / OData v4 service. It reads the service's $metadata and turns it into MCP tools an LLM can call: list, describe, query with validated filters, expand across associations, invoke functions and actions. No per-service code, no hand-written tool definitions. One config, and the service is queryable in natural language.

demo

60-second quickstart

Against the public Northwind service (no auth):

npx cap-mcp-bridge --url https://services.odata.org/V4/Northwind/Northwind.svc

That starts an MCP server on stdio. Wire it into Claude Desktop (claude_desktop_config.json):

{
  "mcpServers": {
    "northwind": {
      "command": "npx",
      "args": ["-y", "cap-mcp-bridge", "--url", "https://services.odata.org/V4/Northwind/Northwind.svc"]
    }
  }
}

Or Claude Code:

claude mcp add northwind -- npx -y cap-mcp-bridge --url https://services.odata.org/V4/Northwind/Northwind.svc

Then ask: "Which German customers have orders shipped to Berlin? Include the company name."

Against your own CAP service running locally with cds watch:

npx cap-mcp-bridge --url http://localhost:4004/odata/v4/catalog

To see what the bridge understood about a service without starting the server:

npx cap-mcp-bridge --url http://localhost:4004/odata/v4/catalog --print-model

Add --json for the same thing as JSON. It leaves out the fetch timestamp, so saving it before a redeploy and diffing afterwards shows exactly which entities, fields and capabilities changed.

What the model gets

A fixed set of tools whose schema is discoverable, rather than four tools per entity set (a real CAP service has 40+ entity sets, which would blow any tool budget):

ToolPurpose
list_entity_setsNames, labels, record counts, draft flag, write capabilities, navigations
describe_entityFull schema of one entity set: properties, types, keys, navigations, filterable/sortable fields
query_entityThe workhorse: filter, select, expand, orderBy, paging, $count
get_entityOne record by key
invoke_functionCall a read-only OData function (unbound or bound)
invoke_actionCall an action. Write mode only
create_entity / update_entity / delete_entityWrite mode only
refresh_metadataRe-read $metadata after a redeploy; re-registers tools if entities changed

Every entity schema is also an MCP resource at cap://entity/{name} (and cap://service for the overview), so a client can pull schemas into context without spending a tool call.

Typed per-entity tools. With toolMode: "auto" (the default), a service with ≤ 12 entity sets gets query_Books, get_Orders, ... instead, with select / expand / orderBy as enums of the real property names. Easier for a model to call correctly, and affordable at that size. Set toolMode to generic or per-entity to force either.

Every description is generated from the service's CDS annotations (@title, @Core.Description, @readonly, @mandatory, @Capabilities.*, @PersonalData.*). Nothing is written per service.

There is prior art in the CAP ecosystem, and the difference is architectural rather than a feature list. Versions and descriptions below are from the npm registry at the time of writing.

PackageWhat it isWhere it runsWhat it reads
@gavdi/cap-mcp (1.8.0)CAP plugin. Scans your service definitions for @mcp annotations and exposes annotated entities as MCP resources with OData v4 query capabilities, functions and actions as tools, plus prompt templates; optional entity wrappers add query / get / create / update tools. Serves MCP from the CAP app itself at /mcp, inheriting the app's authentication.Inside the CAP application (npm install into the CAP project)CAP's compiled model and your @mcp annotations
@neoimpulse/cap-js-mcp (1.0.6)CAP plugin with API-key authentication and configurable directories for your own tools, prompts and resources. Its default tools are search_model and search_docs, described as a generic implementation based on the SAP server below, using cds.model from the running app. The README marks search_docs as a placeholder, and the npm description is unrelated boilerplate.Inside the CAP applicationThe running app's cds.model
@cap-js/mcp-server (0.0.5)SAP's own MCP server, aimed at developers building CAP apps ("AI-assisted development of CAP applications"): search_model over a project's compiled CDS definitions and search_docs over the CAP documentation. It does not query a running service's data.As a separate process (npx -y @cap-js/mcp-server) against a CAP project on diskThe project's CDS sources and the CAP docs
cap-mcp-bridge (this project)A generic OData v4 client exposed as MCP tools: query, get, expand, functions, actions, with schema-validated filters and safety rails.As a separate process, anywhere with HTTP access to the service$metadata over HTTP, nothing else

The two plugins run inside the CAP application: you add them to the CAP project's package.json, and they read CAP's runtime model after the app compiles. cap-mcp-bridge runs outside the service and consumes $metadata over HTTP. That cuts both ways:

  • Where the bridge is the better fit: services you do not own, cannot modify, or cannot redeploy. Third-party SAP systems, locked-down production landscapes, and any non-CAP OData v4 service. It is the reason the Northwind example works at all: there is no CAP application to install a plugin into.
  • Where the plugins are the better fit: if you own the CAP application and can add a dependency. In-process access to the compiled CDS model gives them richer semantics than an EDMX document exposes (CAP-specific annotations that never reach $metadata, custom handlers, the app's own authentication and authorisation applied per user), and there is no second process to run or secure. @gavdi/cap-mcp in particular lets you curate exactly what is exposed through @mcp annotations, which is a more deliberate surface than "everything in the metadata".

If you are writing the CAP service yourself, look at the plugins first. If you are pointed at someone else's OData endpoint, this is the tool.

Filters that self-correct

$filter as a raw string is where LLM-driven OData goes wrong: quoting, date literals, eq null, function syntax. So the preferred form is structured, and the bridge does the quoting:

{
  "entitySet": "Orders",
  "filter": {
    "and": [
      { "field": "ShipCountry", "op": "eq", "value": "Germany" },
      { "field": "Freight", "op": "gt", "value": "100" },
      { "field": "OrderDate", "op": "ge", "value": "1997-01-01" }
    ]
  },
  "select": ["OrderID", "ShipCity", "Freight"],
  "expand": ["Customer"],
  "orderBy": [{ "field": "Freight", "dir": "desc" }],
  "top": 20
}

becomes $filter=ShipCountry eq 'Germany' and Freight gt 100 and OrderDate ge 1997-01-01. Raw $filter strings are accepted too; they are parsed, validated against the schema, and re-serialised.

Both forms go through the same validator: every field must exist, be filterable/sortable per the service's Capabilities annotations, the operator must be legal for the type, and the literal must match it. On failure the model gets something it can act on, before anything reaches the network:

{
  "error": {
    "code": "not_filterable",
    "message": "\"Picture\" is not filterable on Categories. Filterable fields: CategoryID, CategoryName, Description",
    "target": "Picture",
    "validOptions": ["CategoryID", "CategoryName", "Description"]
  }
}

A model that gets this will self-correct on the next turn. A model that gets 400 Bad Request will not.

Drafts. For CAP draft-enabled entities the bridge injects IsActiveEntity eq true unless the caller passes includeDrafts: true, and key lookups default to the active record. Without this, every query on a draft entity returns duplicate rows.

Safety rails

This is what makes the bridge deployable rather than a toy. All on by default:

  • Read-only by default. Write tools only exist when writeEnabled: true (--write).
  • Forced pagination. $top defaults to 25, hard cap 200. $count is always requested. When there is more, the response says so and gives nextSkip.
  • Response size ceiling. ~50KB per response. Rows are dropped from the end with an explicit note saying how many and why. Never silently.
  • Entity allowlist / denylist by name or glob (entityAllow, entityDeny).
  • Field redaction. A configurable list of names/globs (redactFields), plus automatic redaction of anything annotated @PersonalData.IsPotentiallySensitive. Applied inside expanded navigations too.
  • Timeouts and retries. 30s timeout. Retry with backoff on 5xx and 429 only. Never a 4xx, never a write.
  • Logs go to stderr and never contain tokens, passwords, or URLs with filter values.

Configuration

Precedence: CLI flags > CAP_MCP_* environment > cap-mcp.config.json > defaults.

JSON keyEnv varDefaultMeaning
urlCAP_MCP_URLrequiredOData v4 service root
auth.kindCAP_MCP_AUTHnonenone | basic | bearer | oauth2-cc
auth.username / auth.passwordCAP_MCP_USERNAME / CAP_MCP_PASSWORDbasic auth
auth.tokenCAP_MCP_TOKENbearer token passed through
auth.tokenUrl / clientId / clientSecretCAP_MCP_TOKEN_URL / CAP_MCP_CLIENT_ID / CAP_MCP_CLIENT_SECRETXSUAA client credentials
CAP_MCP_SERVICE_KEY_FILEXSUAA service key JSON; fills the three above
transportCAP_MCP_TRANSPORTstdiostdio | http
host / portCAP_MCP_HOST / CAP_MCP_PORT127.0.0.1 / 3333HTTP bind address; port 0 picks a free one
toolModeCAP_MCP_TOOL_MODEautogeneric | per-entity | auto
perEntityThresholdCAP_MCP_PER_ENTITY_THRESHOLD12auto switches to generic above this many entity sets
writeEnabledCAP_MCP_WRITE_ENABLEDfalseregister write tools
defaultTop / maxTopCAP_MCP_DEFAULT_TOP / CAP_MCP_MAX_TOP25 / 200paging
maxResponseBytesCAP_MCP_MAX_RESPONSE_BYTES50000response ceiling
entityAllow / entityDenyCAP_MCP_ENTITY_ALLOW / CAP_MCP_ENTITY_DENYnames or globs, comma-separated in env
redactFieldsCAP_MCP_REDACT_FIELDSnames or globs
timeoutMs / maxRetriesCAP_MCP_TIMEOUT_MS / CAP_MCP_MAX_RETRIES30000 / 3
metadataTtlMsCAP_MCP_METADATA_TTL_MS900000metadata cache TTL (15 min)
logLevelCAP_MCP_LOG_LEVELinfodebug | info | warn | error | silent

Auth kind is inferred when omitted: a token implies bearer, a client id implies oauth2-cc, a username implies basic.

Auth against a BTP-deployed CAP service
export CAP_MCP_URL=https://<app>.cfapps.<region>.hana.ondemand.com/odata/v4/catalog
export CAP_MCP_SERVICE_KEY_FILE=./service-key.json   # XSUAA service key from the cockpit
npx cap-mcp-bridge

The token is cached, refreshed 60s before expiry, and fetched single-flight so concurrent tool calls never stampede the token endpoint. See examples/btp.

Streamable HTTP
npx cap-mcp-bridge --url ... --transport http --port 3333
# POST/GET/DELETE http://127.0.0.1:3333/mcp, health at /healthz

One MCP server per session, all sharing the metadata cache and auth provider.

Docker
docker build -t cap-mcp-bridge .
docker run --rm -p 3333:3333 -e CAP_MCP_URL=https://services.odata.org/V4/Northwind/Northwind.svc cap-mcp-bridge

The image runs the HTTP transport bound to 0.0.0.0:3333. Pass any CAP_MCP_* variable.

Examples

  • examples/northwind: public service, generic tools, deny list and redaction in use
  • examples/bookshop: a small CAP service with every annotation the bridge understands, drafts included. Also the local acceptance target.
  • examples/btp: XSUAA client credentials

How it works

$metadata ──► metadata/  parse EDMX → ServiceModel (annotations folded in, drafts detected)
                 │
                 ▼
             tools/      ServiceModel → MCP tools + resources (generic or typed per-entity)
                 │
                 ▼
             odata/      validate filter/select/expand/orderBy → build URL → auth, retry, paging
                 │
                 ▼
             server/     stdio or streamable HTTP

The ServiceModel is the only contract between layers. Adding support for a new CAP service requires zero code changes because the only input is XML. Design notes and the decisions behind them are in docs/ARCHITECTURE.md.

Type mapping worth knowing: Edm.Decimal is exposed as a string (CAP serialises decimals as strings to avoid float precision loss; the bridge also sends IEEE754Compatible=true). Field descriptions say so.

Development

npm install
npm run typecheck && npm run lint && npm test
npm run dev -- --url https://services.odata.org/V4/Northwind/Northwind.svc --print-model
npx tsx scripts/smoke.ts https://services.odata.org/V4/Northwind/Northwind.svc   # live, over stdio

The end-to-end tests run a real McpServer and Client over an in-memory transport with fetch stubbed to serve fixture metadata, plus real HTTP servers for the auth and transport suites. The bookshop under examples/bookshop provides the CAP fixture (npx cds compile srv --to edmx-v4).

Cutting a release

Releases are published by GitHub Actions (release.yml) through npm trusted publishing (OIDC). There is no NPM_TOKEN secret, and the package page carries a provenance badge linking the tarball to the exact commit and workflow run.

# 1. on main, bump the version and record the changes
npm version 0.2.0 --no-git-tag-version      # edits package.json + package-lock.json
#    add a 0.2.0 section to CHANGELOG.md, open a PR, merge it
# 2. tag the merged commit and push the tag; the workflow publishes
git checkout main && git pull
git tag v0.2.0 && git push origin v0.2.0

The workflow refuses to publish if the tag does not match package.json. One-time setup: npm only lets you register a trusted publisher for a package that already exists, so the very first version is published by hand (npm publish, with 2FA), after which the trusted publisher is added on npmjs.com under the package's Settings (GitHub Actions, repository SanoberRehman/cap-mcp-bridge, workflow release.yml). Provenance is requested only by the workflow (--provenance); a manual publish from a laptop cannot generate it, so it is not set in publishConfig.

Post-publish check
bash scripts/verify-published.sh            # cap-mcp-bridge@latest
bash scripts/verify-published.sh 0.1.0      # a specific version

It runs npx -y cap-mcp-bridge@<version> --print-model against Northwind from a fresh temp directory with a fresh npm cache, so nothing resolves from this repository. It is what catches a missing shebang, an unbuilt dist, or a files array that left something out.

License

MIT

MIT, read

History

Latest

v0.1.0

Features 6

Notes
Added
  • Metadata layer: fetches $metadata over plain HTTP and parses OData v4 EDMX into a ServiceModel, folding CDS annotations (labels, descriptions, readonly, mandatory, personal data, Capabilities) into plain fields, detecting draft-enabled entities, mapping Edm.Decimal to string, and rejecting OData v2 with a clear message.
  • Tool generation from the model: generic tools (list_entity_sets, describe_entity, query_entity, get_entity, invoke_function, refresh_metadata) or typed per-entity tools when a service has at most 12 entity sets; write tools only with writeEnabled; every entity schema as an MCP resource at cap://entity/{name}.
  • Filters: structured objects and raw $filter strings share one AST, validated against the schema (field exists, filterable/sortable, operator legal for the type, literal format) and serialised with type-driven quoting; errors name the field and list valid options; draft entities get IsActiveEntity eq true injected.
  • Auth (none, basic, bearer, oauth2-cc with cached single-flight XSUAA tokens and BTP service-key files) and transports (stdio, streamable HTTP with per-session servers sharing one metadata cache).
  • Safety rails: read-only by default, $top default 25 / cap 200 with $count and nextSkip, ~50KB response ceiling with explicit notes, entity allow/deny globs, field redaction, 30s timeout with retries only on 5xx/429 reads.
  • Packaging: CLI (npx cap-mcp-bridge --url ..., --print-model), Dockerfile, CI on Node 20/22 plus a Docker boot check, examples for Northwind, a local CAP bookshop and BTP, DEMO.md and a demo GIF rendered from a real session.
10downloads per week, npm
Weekly downloads for cap-mcp-bridge26 complete calendar weeks from 2026-05-11 to 2026-11-08; the latest total is 10.11 May – 17 May: 018 May – 24 May: 025 May – 31 May: 01 Jun – 7 Jun: 08 Jun – 14 Jun: 015 Jun – 21 Jun: 022 Jun – 28 Jun: 029 Jun – 5 Jul: 06 Jul – 12 Jul: 013 Jul – 19 Jul: 020 Jul – 26 Jul: 027 Jul – 2 Aug: 03 Aug – 9 Aug: 010 Aug – 16 Aug: 017 Aug – 23 Aug: 024 Aug – 30 Aug: 031 Aug – 6 Sept: 1437 Sept – 13 Sept: 1014 Sept – 20 Sept: 1021 Sept – 27 Sept: 528 Sept – 4 Oct: 35 Oct – 11 Oct: 212 Oct – 18 Oct: 619 Oct – 25 Oct: 526 Oct – 1 Nov: 62 Nov – 8 Nov: 10
Declared alternatives
  1. @gavdi/cap-mcpGenerates an MCP server from annotated CDS entities and actions
  2. @cap-js/mcpExposes CAP services as MCP servers for AI agents
Agent access to your systems
  1. SAP-samples/hana-developer-cli-tool-exampleDeveloper-centric command line for SAP HANA

Details

Sources4
npm registrydiscovered here, keywords:sap-capchecked
npm registry, cap-mcp-bridgeversion, releases, installschecked
github.com/git+https://github.com/SanoberRehman/cap-mcp-bridge.gittree, pushes, contributors, CIchecked
README.mdquoted, and what the entry declareschecked

Sources are graph entities: the same page may back several entries, and an unreachable source flags every row that rests on it.

Compatibility and provenance
runtimesnode
latestv0.1.0
first release
releases and cadence1
discovered vianpm registry · keywords:sap-cap
first seen in the atlas
ecosystem and domaincap, ai-and-agents
History in the atlas2
  1. The concern it answers is reaching into an SAP system from outside, split out of MCP servers on this day; the sentence on the edge is unchanged.
  2. First seen.
For your agent
Ref
artifact:sanoberrehman-cap-mcp-bridge
JSON
/artifacts/sanoberrehman-cap-mcp-bridge.json
MCP
Connecting an agent