MCP White Paper - working draft

White Paper Outline: “Enabling Open Network APIs: How CAMARA APIs can be integrated in LLMs by using the Model Context Protocol"

Reference Model Context Protocol (MCP) EvaluationPreview  

MCP & Identity: https://aaronparecki.com/2025/04/03/15/oauth-for-model-context-protocol , https://www.youtube.com/watch?v=mYKMwZcGynw

Text in Orange to be filled in by MCP group

Text in Red to be updated

(text proposed by @Jill Lovato )

As telecommunications networks evolve to meet the demands of modern digital services, there is a growing need for open, standardized, and developer-friendly APIs that can unlock network capabilities in a seamless, consistent way. This white paper explores how CAMARA APIs (which are open, cross-operator network APIs) can be effectively integrated into Large Language Models (LLMs) through the adoption of the Model Context Protocol (MCP). This integration offers a transformative approach to enabling AI systems to interact with and optimize network resources in real time.

CAMARA, a project under the Linux Foundation, provides standardized APIs that abstract away telecom-specific complexities and make key network capabilities — such as Quality on Demand, Edge Discovery, and Device Location — accessible to application developers. The Model Context Protocol (MCP) complements this by enabling context propagation, dynamic policy enforcement, and interoperability across heterogeneous systems. MCP ensures that LLMs can access and utilize real-time application and user context to inform decisions when invoking CAMARA APIs.

By combining CAMARA APIs with MCP, application developers and AI service providers can:

• Deliver more intelligent, context-aware services powered by dynamic network capabilities.

• Reduce integration complexity and accelerate time-to-market by relying on open standards.

• Enable AI models to make real-time, policy-compliant decisions that optimize user experience and resource utilization across diverse operator environments.

This integration represents a significant step toward bridging the gap between AI applications and telecom networks, driving new levels of innovation and operational efficiency. The following sections of this white paper outline the technical approach, use cases, and strategic benefits of embedding CAMARA APIs into LLM workflows through the Model Context Protocol.

[pull text from Introduction wiki page]

• The challenge of network API fragmentation in telecoms

• The need for cross-operator, standardized interfaces

• Benefit for integrating it in LLMs

• Role of CAMARA APIs + MCP  in solving these problems (high level - we can put the strategic message here)

(text prposed by @Jill Lovato )

As mentioned in the Executive Summary, the telecommunication industry faces persistent fragmentation in API ecosystems: each operator offers proprietary interfaces for network services. This siloed landscape forces developers to implement multiple bespoke integrations, which hampers innovation, slows adoption, and limits the potential of network-aware applications.

There’s a critical need for cross-operator, standardized interfaces to unify access to network-native capabilities. The CAMARA initiative under the Linux Foundation directly addresses this challenge, defining open, operator-agnostic APIs for essential network functionality. However, standardization alone is insufficient unless these APIs can be seamlessly integrated into modern application workflows.

Large Language Models (LLMs) and AI agents are uniquely positioned to bridge this gap. But by themselves, AI systems lack the means to access context-rich, dynamic network environments securely and consistently. That’s where the Model Context Protocol (MCP) comes in. Initially defined by the CAMARA Technical Steering Committee in April 2025, the MCP evaluation effort aims to:

• Provide concrete examples of interworking between AI agents, MCP, and CAMARA APIs

• Convey strategic messaging around MCP's role within the CAMARA ecosystem

• Identify technical adjustments required in CAMARA to support MCP-driven integration

• Explore enhancements to MCP for alignment with CAMARA’s privacy, security, and operational model 

[side bar with link to this video and screen grab image youtube.com+9lf-camaraproject.atlassian.net+9lf-camaraproject.atlassian.net+9lf-camaraproject.atlassian.net ]

MCP enables LLMs to dynamically discover and consume structured context (such as user identity, session parameters, consent status, device attributes, and QoS requirements) and apply these when calling CAMARA APIs. This ensures AI-driven workflows are context-aware, compliant, and operator-neutral.

In this white paper, we posit that CAMARA APIs powered by MCP-equipped LLMs can revolutionize telecom application development, further reducing complexity, increasing agility, and unleashing AI-enhanced services that seamlessly adapt to real-time network conditions across operators.

[sidebar 2: 

CAMARA + MCP: A Synergy for AI-Driven Network Access

CAMARA and Model Context Protocol (MCP) represent complementary approaches to API interoperability that could create powerful synergies.

CAMARA harmonizes telecom network capabilities through well-defined, intent-based APIs that work consistently across different operators, while MCP provides a structured framework for AI systems to interact with external tools and services, like service offered via CAMARA APIs.

By mapping CAMARA API artifacts into MCP tool and resource definitions, we can enable AI agents to seamlessly access network capabilities without needing to understand the underlying telecom complexities. This integration would allow developers to build AI applications that can leverage telco network capabilities through natural language interactions, potentially creating new use cases and expanding CAMARA's adoption beyond traditional API consumers into the rapidly growing AI agent ecosystem. /end side bar]

• Overview  & history of the CAMARA project

  • Mission: Define, standardize, and validate network APIs for developers

  • Key use cases and APIs (e.g., Quality on Demand, Device Location, Edge Discovery)

(text proposed by @Jill Lovato )

As discussed, CAMARA is an open source initiative hosted by the Linux Foundation, created to solve a fundamental challenge in telecoms: making advanced network capabilities easily accessible to developers in a consistent and operator-neutral way. Launched in early 2022 through a collaboration between leading telecom operators and global technology companies, CAMARA set out to standardize the fragmented ecosystem of network APIs and accelerate the development of new digital services.

The project’s core mission is to define, standardize, and validate open network APIs that abstract the complexity of telecom infrastructure. By offering intent-based APIs, CAMARA empowers developers to request services—such as prioritized connectivity, device status, or optimal edge resource discovery—without needing in-depth knowledge of the underlying network technologies.

CAMARA APIs are designed around real-world application needs, with early use cases focusing on areas like:

• Quality on Demand (QoD): Dynamically request enhanced connectivity performance based on application or user context.

• Device Location: Retrieve verified device location data in a privacy-respecting manner, enabling new location-based services.

• Edge Discovery: Discover the most optimal edge computing resources based on proximity, latency, and network performance.

With a developer-first philosophy and alignment with the GSMA Open Gateway initiative, CAMARA is becoming a critical bridge between global telecom networks and the broader application ecosystem—including emerging AI-based services.

• Original nput for the section:

  • Definition and origin of MCP

    • Goals: Context propagation, dynamic policy enforcement, and interoperability (mostly ignored)

    • Use in service meshes, multi-cloud systems, and programmable networks (ignored, too many buzzwords)

  • include language on how MCP has done the same work to “standardize” the way AI apps interact with APIs in the same way CAMARA has for telco APIs. Both making it easier for multiple LLMs/telcos to consume resource

  • Clarify what MCP adds

Text proposal by @Herbert Damker

The Model Context Protocol (MCP) is an open protocol that standardizes how applications provide context to Large Language Models (LLMs). Just as USB-C provides a standardized way to connect devices to various peripherals and accessories, MCP provides a standardized way to connect AI models to different data sources and tools.

The Model Context Protocol is an open protocol that enables seamless integration between LLM applications and external data sources and tools. Whether building an AI-powered IDE, enhancing a chat interface, or creating custom AI workflows, MCP provides a standardized way to connect LLMs with the context they need. Originally developed by Anthropic and announced in November 2024, MCP has rapidly gained industry adoption, with major players including OpenAI, Microsoft Azure, and various cloud providers integrating the protocol into their AI platforms. <add sentence about available MCP Servers for many existing services>

At its core, MCP follows a client-server architecture where a host application can connect to multiple servers: MCP Hosts are programs like Claude Desktop, IDEs, or AI tools that want to access data through MCP; MCP Clients are protocol clients that maintain 1:1 connections with servers; MCP Servers are lightweight programs that each expose specific capabilities through the standardized Model Context Protocol.

The protocol uses JSON-RPC 2.0 messages to establish communication between hosts, clients, and servers. MCP supports multiple transport mechanisms including stdio transport for local processes and Streaming HTTP for remote communication.

Open

Servers offer features including: Resources (context and data for users or AI models), Prompts (templated messages and workflows), and Tools (functions for AI models to execute). Clients may offer features including Sampling (server-initiated agentic behaviors), Roots (server-initiated inquiries into filesystem boundaries), and Elicitation (server-initiated requests for additional information from users).

CAMARA APIs can be exposed as Tools through MCP servers, making network capabilities immediately accessible to any MCP-compatible AI application.

MCP implements comprehensive security principles including user consent and control (users must explicitly consent to and understand all data access and operations), data privacy (hosts must obtain explicit user consent before exposing user data to servers), tool safety (tools represent arbitrary code execution and must be treated with appropriate caution), and LLM sampling controls (users must explicitly approve any LLM sampling requests).

This security-first approach aligns closely with CAMARA's privacy-first design principles, particularly around consent management and data protection, making MCP an ideal protocol for exposing sensitive telecom network capabilities to AI systems.

The relationship between MCP and CAMARA represents a powerful convergence of efforts in complementary domains. Just as CAMARA has defined network API interfaces to eliminate fragmentation across network operators, MCP is specifying the interface between AI applications and data sources, eliminating the need for custom integrations between different LLM providers and external systems.

Both protocols share the fundamental goal of reducing complexity for developers. CAMARA allows developers to build applications that work across multiple network operators without operator-specific code, while MCP enables developers to build AI applications that can switch between different LLM providers while maintaining consistent access to tools and data sources. This parallel approach to standardization creates a natural synergy where CAMARA APIs can be exposed through MCP servers, making network capabilities immediately accessible to any MCP-compatible AI application.

Work in Progress - Use Case (section 4)Preview

• Network capabilities exposed by CAMARA and use of them by AI Agents

• LLM doing flight planning for drones and asking for population density data

• Network slice booking (does not require consent from enterprise side)

  • LLM creating drone flight path could book a slice path - helps with automation piece

• LLM planning live video production (e.g. big sporting event or music festival)

• Anything related to fraud management - security & identity?

  • chatbot wanting to confirm information from customer when taking an order (AI personal shopper and the ways it verifies information against fraud)

  • enterprise - AI doing customer verification on data

  • bank chatbot verifying customer info (uses SIM Swap, device location, etc.)

  • KYC match

• Developer-centric APIs

• OpenAPI specifications

• Abstraction from telco-specific complexities

• Policy and security enforcement layers

• Context-as-a-primitive concept

• Decoupling service behavior from infrastructure

• Context injection, propagation, and validation mechanisms

Text proposal by @Tanja de Groot

MCP is built on several key design principles that guide its architecture and implementation:

1. Simplicity: Servers should be extremely easy to connect. They focus on specific, well-defined capabilities and provide simple interfaces that minimize implementation overhead.

2. Interoperability: Single (standardized) protocol enabling (MCP host) applications to select amongst multiple MCP servers. Such servers provide tools to access data sources (like API integrations) and prompts (templated interactions) regardless of the provider.

3. Composability: Each MCP server provides focused functionality independently of other MCP servers. This allows to compose the use of multiple servers inside one (MCP host) application.

4. Modularity: the MCP client-server design allows for a clear separation of concerns and enables maintainable bi-directional communication and easy extensibility. An MCP server receives only the contextual information necessary for its processing.

5. Extensibility / Evolvability: new capabilities and message types can be introduced (at MCP client or server side) without breaking existing integrations using the capability negotiation part of the MCP protocol at session initiation time. This ensures long-term adaptability as use cases expand.

6. Security: Built-in access controls and permissions from the ground up including

   • MCP server-based authentication and authorization

   • Data separation between users.

   • The use of elicitation for user input requests without interfering with the current session in particular when users would be prompted to grant additional consent.

   • Minimal exposure of sensitive information between servers according to the current context. Each server processes only the part of the shared context relevant to its functionality. This reduces coupling between servers and improves security and privacy.

7. Observability / Transparency / Attribution: MCP enables traceability of requests and visibility into the server execution, supporting logging/debugging, analytics, and governance. The use of MCP allows for maintaining clear sourcing of information.

6.3 Integration Architecture - (@Nick Venezia @Jesús Peña García-Oliva (see input in comments, can review afterwards))

WIP - 6.3 Integration ArchitecturePreview

• How would an AI access a CAMARA API via MCP? [include general MCP architecture pic we already have - extend it]

  • Enhanced Service APIs

  • Expected deployments of MCP Servers

• How CAMARA APIs are enriched via MCP context injection* [needs clarification]

• Identity & Consent Management

  • Interaction points between CAMARA APIs and MCP (e.g., policy enforcement, dynamic QoS decisions)

  • [CAMARA already very focused on privacy-first]

[add diagram - simplified https://modelcontextprotocol.io/specification/2025-03-26/architecture ]

7. 1 Benefits for developers

   1. Lower development overhead for app developers

7.2 Benefits for Operators

• Increased operator agility and innovation

• Real-time, context-aware policy decisions (actual enterprise related, not operator)

7.3 Benefits for application users

• Improved cross-network consistency (coming from CAMARA - CAMARA provides source of truth for LLMs)

• Original input for the section:

  • Need for ecosystem-wide adoption of context standards

  • Vendor and operator coordination

  • Security challenges

  • Upcoming CAMARA APIs that will integrate MCP

  • Plans for dynamic service chaining and AI-driven context inference

  • Interoperability with other telco initiatives (Open Gateway, ETSI, etc.)

Text proposal based on the material from Potential technical work in CAMARA to support MCPPreview (not necessarily a fit for the bullet points above)
WIP - 8. Future Roadmap: Challenges and ConsiderationsPreview

• Recap of synergy between CAMARA APIs and MCP

• Strategic value for telcos and developers

• Call to action for community participation and adoption