canonical: https://jentic.com/apis/mef.nrp.net/mef-nrp

# MEF NRP API

Jentic publishes the only available OpenAPI specification for MEF NRP API, keeping it validated and agent-ready. The MEF Network Resource Provisioning API is a standards-based interface defined by the MEF Forum for managing network connectivity at the carrier-network layer. The 10 endpoints model two core resources - ForwardingConstruct and LogicalTerminationPoint - supporting create, read, update, delete, and state-based queries. It is used by carriers and large enterprises to programmatically provision and inspect MEF-aligned network services.

## For AI agents

Provision and inspect MEF Network Resource Provisioning forwarding constructs and logical termination points so an agent can automate carrier-grade network connectivity changes.

## Scope

Does not handle billing, customer ordering, or device-level configuration - use for MEF-standard ForwardingConstruct and LogicalTerminationPoint operations only.

## Capabilities

- List ForwardingConstructs across the carrier network
- Filter ForwardingConstructs by lifecycle state to find pending or active services
- Retrieve a specific ForwardingConstruct by id including its endpoints and constraints
- Update a ForwardingConstruct to change capacity, endpoints, or admin state
- List LogicalTerminationPoints attached to a UNI or ENNI interface
- Read a specific LogicalTerminationPoint by uniID for inventory or troubleshooting

## Use cases

### Automated Network Service Provisioning

Carrier operations teams use the MEF NRP API to provision Ethernet services across a multi-domain network without writing per-vendor element-manager scripts. A single POST or PUT against ForwardingConstruct creates the end-to-end service and returns the resulting object for verification. This compresses multi-day manual provisioning into a single transaction with a uniform contract.

Example prompt: Create a ForwardingConstruct connecting LogicalTerminationPoints uniID=A and uniID=B with a 1Gbps capacity and admin state=ACTIVE.

### Network Inventory Reconciliation

Reconcile an inventory database with the live MEF NRP view by listing ForwardingConstructs and LogicalTerminationPoints and diffing fields such as capacity, admin state, and endpoint references. Operations and finance teams use this nightly to catch services that drifted from the order-of-record. It eliminates the manual element-manager export step that legacy operations workflows usually require.

Example prompt: List all ForwardingConstructs and emit a diff of admin_state and capacity against the inventory snapshot from yesterday.

### Service-State Monitoring and Alerting

Run a scheduled query against ForwardingConstruct/findByState to catch services stuck in pending or fault states and alert the on-call NOC. Because state filtering is a first-class endpoint, the operations agent can run cheap polls without iterating the full inventory. NOC teams use this to drive a paging policy that reflects the actual MEF service model.

Example prompt: Call `/ForwardingConstruct/findByState` with state=PENDING every five minutes and page the NOC if the count is greater than zero for more than 30 minutes.

### Agent-Driven Capacity Adjustment

When a customer requests a capacity bump, an agent can validate the existing ForwardingConstruct, raise the bandwidth, and confirm the change all through MEF NRP. With Jentic the agent searches by intent, loads the schema for the update operation, and executes it inside a guarded workflow. This turns a ticket-driven carrier change into an autonomous one without touching vendor element managers.

Example prompt: Retrieve ForwardingConstruct id=fc-7841, increase its capacity from 1Gbps to 5Gbps via the update operation, and confirm the returned admin_state is ACTIVE.

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| GET | `/ForwardingConstruct` | List ForwardingConstructs |
| GET | `/ForwardingConstruct/findByState` | List ForwardingConstructs filtered by lifecycle state |
| GET | `/ForwardingConstruct/{id}` | Retrieve a single ForwardingConstruct |
| PUT | `/ForwardingConstruct/{id}` | Update a ForwardingConstruct |
| GET | `/LogicalTerminationPoint` | List LogicalTerminationPoints |
| GET | `/LogicalTerminationPoint/{uniID}` | Retrieve a LogicalTerminationPoint by UNI id |

## Key resources

- **ForwardingConstruct** — Manage end-to-end forwarding constructs that represent MEF network services
- **LogicalTerminationPoint** — Inspect logical termination points such as UNIs and ENNIs at customer and network interfaces

## Why Jentic

- **Setup:** Wiring the MEF NRP interface by hand means pointing at the carrier's mef.nrp.net host and hand-coding each ForwardingConstruct and LogicalTerminationPoint call, including the findByState filter. Through Jentic you install once, import the MEF NRP API from the API Directory, store any deployment credential once, and your agent calls it.
- **Permission scoping:** MEF NRP puts the resource id in the URL path (`/ForwardingConstruct/{id}`), so a rule can pin your agent to reading forwarding constructs and termination points. You choose the operations it may call, so the state-changing PUT on `/ForwardingConstruct/{id}` is included only if you add it.
- **Credential handling:** Any credential your MEF NRP deployment requires is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'list MEF forwarding constructs in pending state' or 'read a logical termination point', and Jentic returns the matching MEF NRP operation with its exact path and parameter schema, including the state filter on findByState, so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Cloudflare API** — Cloudflare provides edge networking and connectivity at the application layer rather than the carrier layer.
- **DigitalOcean API** — DigitalOcean exposes cloud networking primitives that often terminate on the customer side of an MEF NRP service.
- **Akamai API** — Akamai's edge platform sits in front of the network capacity that MEF NRP provisions.

## FAQ

### Why is there no official OpenAPI spec for MEF NRP API?

MEF Forum publishes the NRP standard as YANG models and reference documents rather than as a maintained OpenAPI specification. Jentic generates and maintains this spec so that AI agents and developers can call MEF NRP API via structured tooling. It is validated against the live API and kept up to date. Get started with Jentic One, the self-hosted execution layer.

### What authentication does the MEF NRP API use?

The reference spec does not declare a security scheme - auth is provided by the carrier deploying the API, typically TLS client certificates or bearer tokens issued by the operator. When you call it through Jentic, the operator-specific credentials are stored encrypted in the vault and injected at execution time.

### Can I list ForwardingConstructs by state?

Yes. The `/ForwardingConstruct/findByState` endpoint accepts a state parameter and returns the constructs matching that lifecycle state, which is more efficient than listing all and filtering client-side.

### What are the rate limits for the MEF NRP API?

Rate limits depend on the carrier deployment - the MEF reference spec does not define numerical limits. Treat write operations against /ForwardingConstruct conservatively and back off on 429 or 503 responses before retrying through Jentic.

### How do I update a ForwardingConstruct through Jentic?

Search Jentic for update an MEF ForwardingConstruct, load the schema for the PUT on `/ForwardingConstruct/{id}`, and execute with the id and changed fields such as capacity or admin_state. Jentic returns the updated object so the agent can verify the change.

### Is the MEF NRP API a public API?

No - MEF NRP is implemented by individual carriers and exposed only to that carrier's customers and operations teams. The OpenAPI spec describes the standard contract; the actual base URL and credentials come from the carrier deploying it.

### Can I limit what my agent is allowed to do with the MEF NRP API?

Yes. Because you run Jentic One yourself, you decide which MEF NRP operations your agent may call, and your own rules govern which deployment credentials it uses. Since the resource id sits in the URL path, such as `/ForwardingConstruct/{id}`, you can pin the agent to read-only calls like listing ForwardingConstructs, filtering them by state via findByState, and reading a LogicalTerminationPoint by uniID. The state-changing PUT on `/ForwardingConstruct/{id}` is available to the agent only if you explicitly allow it.