13.6 Using OLIVE from AI Agent Applications
Overview
OLIVE can be driven from an AI agent application — OpenAI's ChatGPT, Anthropic's Claude, or any other agent interface — instead of, or alongside, the connectivity editor. The agent application becomes a conversational front end to the platform: you describe what you want in its chat interface, and it works with OLIVE's public APIs on your behalf.
There are two ways to connect an agent application to OLIVE:
- As an MCP server, instantiated from the MCP template delivered with the development package. The MCP template lets you create an MCP server from connectable elements you have registered, and each selected element becomes a tool the agent can call.
- By importing OLIVE's OpenAPI specification into the agent application, which onboards OLIVE's public REST APIs without going through MCP.
The two routes differ in what the agent ends up seeing. An OpenAPI import gives it OLIVE's public REST APIs as they are. An MCP server gives it whatever you selected — which may be the connectors of one solution, or, if you register datapoints for OLIVE's public REST APIs and select those, the platform APIs themselves.
In both cases you can point the agent at this documentation, so that it can look up how OLIVE's concepts work rather than guessing at the metamodel. Which route fits better depends on the agent application you use and on how you prefer to work.
How to Integrate AI describes AI inside connectivity: a solution that calls an LLM or an agent as part of its own execution. This page describes the reverse — an external agent application calling OLIVE. The two are independent and can be used together.
What You Can Do With It
Once the agent application can reach OLIVE's public REST APIs — through an OpenAPI import, or through an MCP server whose selected elements wrap those APIs — you can work with the platform from the agent's interface:
- Query content — ask what connectable elements exist, what a connector does, how an element is configured.
- Create connectivity — have the agent create datapoints and instances of the different connector types.
- Execute connectivity — trigger a connectable element and let the agent poll the job until it completes.
- Query job results — ask for the result of a job, or have the agent interpret it.
An MCP server built from a solution's own connectable elements is a different and equally common case: there the agent does not administer OLIVE, it uses the solution. The agent calls your connectors as tools and OLIVE executes them.
We recommend creating Auth entries yourself in the connectivity editor rather than having the agent create them.
An Auth entry carries credentials. Letting an agent create one means passing a client secret, API key or password through a chat interface and into a model provider's infrastructure. Create the Auth entry by hand, and let the agent reference it by id in the datapoints it builds. See Authentication and Secrets Management.
Anything the agent reads — element definitions, input data, job results — is sent to the model provider that runs the agent application. Apply the same data-policy considerations as for any AI integration before pointing an agent at a tenant that holds real data. See How to Integrate AI – Data Policies.
Option A: Expose Connectable Elements as an MCP Server
OLIVE can expose an MCP server through its MCPServer extension, which is served by the mcp-server-caller service — the concept and the structure of an instance are described in Metamodel – MCPServer.
You do not have to assemble an MCP server instance yourself. An MCP template is delivered with the development package, and you use that template to create one.
What the MCP template does
The MCP template lets you instantiate a new MCP server from connectable elements you have registered. Any registered element can be selected, and each one becomes an MCP tool that the agent application can call; the server can additionally expose resources and prompts, as described for the MCPServer extension.
What the agent can do is therefore decided by what you select:
- Select the connectors and datapoints of a solution, and the agent can use that solution — it calls them as tools and OLIVE executes them.
- Select datapoints that call OLIVE's public REST APIs, which you register beforehand like any other datapoint, and the agent can work with the platform itself: query content, create elements, execute connectivity and poll jobs. This is one particular use case rather than what an MCP server does by default.
Nothing is registered automatically. An instantiated MCP server exposes exactly the elements you chose for it, and you can instantiate several servers for different purposes.
1. Import the MCP template scenario
Take the MCP template scenario from the latest development package and import it into your tenant as an OLIVE Connectivity Bundle (OCB), through the connectivity editor under Service Management → Import OLIVE Connectivity Bundle (OCB).
In a production deployment, importing requires the admin role. See How to Package a Use Case Solution.
2. Register the elements you want to expose
The elements the MCP server is to offer have to exist in the connectivity editor first. For a solution, these are its own connectable elements.
Defining input and output schemas on these elements is what tells an agent how to call them and what comes back: Metamodel – JSONSchema.
If the goal is to let the agent work with the platform itself, do not write those datapoints by hand. Use the OpenAPI import with OLIVE's own OpenAPI specification: it generates one datapoint per endpoint of the public APIs, together with the corresponding input and output schemas — which is exactly what an agent needs in order to call them correctly.
Assign a tag during the import, so that the generated datapoints are easy to find again when you select the elements for the MCP server.
See OpenAPI Import for the dialog, and Technical documentation for OLIVE – API Documentation for the specification of your deployment.
3. Instantiate a new MCP server from the template
Go to the OLIVE Start Page, open the Templates Configurator — which lists all scenario templates available in the tenant — and select the MCP template. See User Interfaces.
Provide the parameters it asks for, including the connectable elements the server is to expose. Confirming the dialog instantiates the scenario: the corresponding elements are created in the connectivity editor, and the MCP server becomes available through the mcp-server-caller service.
How templates, parameters and instantiation work in general is described in How to Customize and Parametrize Connectivity.
4. Connect the agent application to the MCP server
The MCP server is reached over HTTP at the URL generated by the mcp-server-caller service, in the form:
{{envURL}}mcp-server-caller/mcp/<mcpID>
where <mcpID> is the id of the instantiated MCP server. Register that URL in the agent application as an MCP server — how this is done differs per application, so follow the instructions of the application you use.
Option B: Import the OpenAPI Specification
Agent applications that can onboard REST APIs directly — through an OpenAPI import, custom actions, or a comparable mechanism — can work with OLIVE without MCP in between.
OLIVE's public HTTP APIs are documented with OpenAPI version 3.0 and the specification is part of the generated Technical Documentation of your deployment.
See Technical documentation for OLIVE – API Documentation. Hand that specification to the agent application, and the public APIs become available to it as operations it can call.
You can give the agent this documentation here as well — point it at the documentation of your deployment, or at the handbook, and tell it to look up what it needs. The agent can then consult the same concepts it would reach through an MCP resource.
Comparing the Two Routes
| MCP server from the template | OpenAPI import | |
|---|---|---|
| What the agent sees | The connectable elements you selected, as tools, plus any resources and prompts you configured | OLIVE's public REST APIs as the specification describes them |
| Setup | Register the elements, instantiate the template, register one URL in the agent application | Hand the specification to the agent application |
| Requires | An agent application that supports MCP | An agent application that can import an OpenAPI specification |
| Scope control | You decide element by element what the agent can reach | The specification covers the public APIs |
Both are valid ways of working, and nothing stops you from using both — an MCP server and an OpenAPI import can exist side by side, and several MCP servers can serve different purposes. Use whichever fits the agent application at hand.
Authentication
The agent application is an external caller of OLIVE's public APIs, so the deployment it talks to decides whether it has to authenticate:
- In a development deployment there is no authentication, and the public APIs can be used without any credentials. Nothing has to be configured in the agent application, which is what makes this the easiest environment to start in.
- In a production deployment the public APIs are authenticated, so the agent application has to authenticate as well.
Which authentication mechanism applies depends on the environment and on what the agent application supports, and the credentials are provided during tenant onboarding. See API Access with OIDC Clients for what onboarding provides, and ask your Tenant Admin which mechanism is in place for the environment you are connecting to. How the credentials are then configured differs from one agent application to the next, so follow the instructions of the application you use.
Whatever identity the agent ends up acting under, give it the least privilege that covers what you want it to do: reading connectivity, triggering it and polling jobs needs less than creating and changing elements, and an agent should not act with administrative permissions. See Roles In OLIVE and Do not execute connectivity as an administrator.
An agent that builds a datapoint calling an OLIVE API — file-storage-service or session-memory, for example — has to reference an Auth entry in it for the solution to work in a production deployment. The agent's own credentials do not apply to the calls the connectivity makes while it runs. See Calling OLIVE's own APIs from connectivity.
Working With an Agent on Connectivity
A few practices make the difference between a useful assistant and a repository nobody can maintain:
- Review what the agent creates. Elements an agent writes into the repository are ordinary connectivity, executed inside the platform's trust boundary like anything else. Read the definitions before you rely on them, and have them security-reviewed before a production tenant: Security in Connectivity Engineering.
- Define input and output schemas. Schemas are what tell an MCP client how a tool expects to be called and what it returns. They are not enforced at runtime, but they are what makes an element usable by an agent: Metamodel – JSONSchema.
- Insist on the naming conventions and tags. An agent will happily invent its own identifiers. Give it the conventions and have it tag what it creates with the scenario shorty, or packaging the result later becomes guesswork: Naming Convention Guidelines.
- Work in a development deployment. Let an agent create and iterate there, then package the result and take it into productive use the normal way: How to Package a Use Case Solution.
Related
- Metamodel – MCPServer — the extension behind the MCP server, and what else it can expose
- Calling OLIVE Platform APIs — the same APIs called from a script or an API client tool
- API Access with OIDC Clients
- Technical documentation for OLIVE
- How to Integrate AI — AI used inside connectivity, the other direction