Skip to main content

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.

This is the opposite direction from "How to Integrate AI"

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.

Create Auth entries manually

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.

What the agent sees leaves your tenant

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.

Use the OpenAPI import to register OLIVE's public datapoints

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 templateOpenAPI import
What the agent seesThe connectable elements you selected, as tools, plus any resources and prompts you configuredOLIVE's public REST APIs as the specification describes them
SetupRegister the elements, instantiate the template, register one URL in the agent applicationHand the specification to the agent application
RequiresAn agent application that supports MCPAn agent application that can import an OpenAPI specification
Scope controlYou decide element by element what the agent can reachThe 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.

The datapoints the agent creates still need their own auth

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.