Lab 1: Deploy an agentic blueprint

In this lab you deploy three AI agents in your cluster and chat with them in MX-UI. The agents come from two blueprints (ready-made sets of agents):

• the Supervisor, from the Supervisor blueprint: it receives your question and asks the right agents;
• the KPI agent, from the Observability blueprint: it measures how your networks perform (throughput, PRB usage, radio quality, CPU, memory);
• the Topology agent, from the Observability blueprint: it tells what your networks are made of (core, gNBs, cells, UEs).

By the end of this lab you will be able to:

• install the catalog of a blueprint in your cluster;
• write an AIFabric file that picks agents from blueprints;
• deploy the AIFabric with brc;
• chat with the agents in MX-UI.

Before you start, read the prerequisites and the terminology. Run the commands of this lab on the cluster master node, where brc is installed.

Part 1: What you will deploy

                 You, in MX-UI
                       │
                ┌──────▼──────┐
                │ Supervisor  │          supervisor/base
                └──┬───────┬──┘
           asks    │       │    asks
             ┌─────▼─┐   ┌─▼────────┐
             │  KPI  │   │ Topology │    observability/kpi
             └───┬───┘   └────┬─────┘    observability/topology
                 │            │
         VictoriaMetrics   your Network and
         MCP server        Terminal resources
         (the metrics)     (what you deployed)

A blueprint has many agents. The Observability blueprint, for example, has agents for KPIs, topology, logs, alerts and more. Its CompositionModel, named observability, is the catalog of these agents: one mode per agent. You pick an agent by writing <model>/<mode>:

• observability/kpi is the KPI agent of the Observability blueprint;
• observability/topology is its Topology agent;
• supervisor/base is the Supervisor.

You don't have to deploy every agent of a blueprint. You can compose your own blueprint by combining agents from other blueprints. Here you combine the Base Supervisor of the Supervisor blueprint with two agents of the Observability blueprint: KPI, and Topology.

Part 2: Before you start

Step 1: Install the blueprint catalogs

Install the CompositionModels of the two blueprints:

brc install model supervisor
brc install model observability

Check that they are installed:

brc list model

You should see supervisor and observability in the list of Composition Models.

Step 2: Create the API key Secret

This lab uses OpenAI. If you have not done it yet, create the Secret openai-api-key with your OpenAI API key, as explained in Create the OpenAI API key Secret.

If you use another LLM provider, free-tier LLMs with OmniRoute, or local models with Ollama, the procedure changes accordingly: follow Using another LLM instead.

Step 3: Deploy a network to observe

The agents answer questions about your 5G networks, so you need at least one running network. It must have a RIC with a monitoring xApp: the KPI agent reads the throughput from the RIC's measurements.

If you already have such a network, skip this step and use its name instead of o-ran in the rest of the labs.

Otherwise, deploy the network of Lab 3: O-RAN Basic of the Network Design Training. Save its file open-ran.yaml, then run:

brc install network open-ran.yaml

It creates a network called o-ran, with a RIC, a monitoring xApp and two simulated UEs, ue1 and ue2. Check it:

brc list network

You should see the network o-ran and the terminals ue1 and ue2. Wait until they are all ready: it can take a few minutes.

Part 3: Write the AIFabric

The AIFabric is the file that says which agents to run, which LLM they use, and which MCP servers they can reach. Save the file below as observability-lab.yaml. Keep it: you will change it in Lab 4.

observability-lab.yaml

apiVersion: orama.trirematics.io/v1
kind: AIFabric
metadata:
  name: observability-lab
  namespace: trirematics
spec:
  telemetry:
    endpoint: http://phoenix-svc.monitoring.svc.cluster.local:6006
    projectName: observability-lab
  llms:
    - name: openai
      provider: openai
      model: gpt-6-luna
      reasoningEffort: low
      apiKeySecretRef:
        name: openai-api-key
        key: OPENAI_API_KEY
  mcp:
    - name: victoria-metrics
      type: external
      external:
        baseUrl: http://vmm-victoria-metrics-mcp.monitoring.svc.cluster.local:8080/mcp
  agents:
    - name: supervisor
      type: internal
      internal:
        model: supervisor/base
        llm: openai
        role: supervisor
    - name: kpi
      type: internal
      internal:
        model: observability/kpi
        llm: openai
        role: worker
        mcpServers:
          - victoria-metrics
    - name: topology
      type: internal
      internal:
        model: observability/topology
        llm: openai
        role: worker

What each part means:

Part	Meaning
kind: AIFabric	This file is an AIFabric.
metadata.name	The name of your fabric: observability-lab.
metadata.namespace	Where the agents run: trirematics. The CompositionModels you installed are there too.
telemetry	Where the agents send their traces: a record of every step they take, every LLM call and every call to another agent. endpoint is the address of Phoenix, the trace viewer of your cluster. projectName groups the traces of this fabric; here it has the fabric's name. See Phoenix to open it and read the traces.
llms	The LLMs the agents can use. name is a label you choose. provider and model say which LLM to call. reasoningEffort: low makes answers faster and cheaper. apiKeySecretRef points to the Secret you created in Part 2.
mcp	The MCP servers the agents can use. victoria-metrics is already running in your cluster (type: external), so you only give its address. It holds the network metrics.
agents	The agents to run. Each one has a name you choose (lowercase letters, digits and dashes).
type: internal	The cluster runs this agent for you, from a CompositionModel.
internal.model	Which agent to run, as <model>/<mode>.
internal.llm	Which LLM of the llms list the agent uses.
internal.role	supervisor for the Supervisor, worker for the others. The Supervisor can call every worker.
internal.mcpServers	Which MCP servers of the mcp list the agent can use. KPI reads the metrics, so it needs victoria-metrics.

💡 Not using OpenAI? Replace the llms part as shown in Using another LLM, and keep name: openai.

💡 Names matter. Agents call each other by these names. Keep them as they are.

Part 4: Deploy the AIFabric

brc install aifabric observability-lab.yaml

You should see:

aifabric.orama.trirematics.io/observability-lab created

Now open MX-UI and go to the Fabrics page. Find observability-lab. Wait until the fabric and its three agents are ready.

ℹ️ The Supervisor starts last: the cluster waits until KPI and Topology are ready, so that the Supervisor finds them when it starts. A Supervisor that is still waiting is normal.

Part 5: Chat with the agents

In MX-UI, go to the Chats page, select the fabric observability-lab and choose the Supervisor. Try these questions:

1. Which networks are deployed? The Supervisor asks the Topology agent.
2. What is the downlink and uplink throughput of each network right now? The Supervisor asks the KPI agent.
3. Which networks are deployed, and what is the downlink throughput of each one? The Supervisor asks both agents and puts their answers together.

Now choose the KPI agent instead of the Supervisor, and ask question 2 again. The answer comes faster, because the Supervisor no longer passes the question on. The Supervisor is useful when a question needs more than one agent, like question 3.

💡 No traffic, no throughput. A simulated UE sends little traffic, so the throughput can be close to 0 Mbps. To create traffic for 60 seconds, run:

brc test throughput ue1 dl gateway -- --time 60

and ask the question again while the test runs.

If something goes wrong

What you see	What to do
brc list model does not show supervisor or observability.	Run the two brc install model commands of Part 2 again and read their error message.
In MX-UI, the fabric is still not ready after 5 minutes.	Open the fabric in MX-UI and look for the agent that is not ready, and its message. A Supervisor that waits for KPI or Topology means the problem is in KPI or Topology.
The agents answer with an authentication or API key error.	Check that the Secret openai-api-key exists and holds your OpenAI key in OPENAI_API_KEY. Fix it, then run brc remove aifabric observability-lab.yaml and brc install aifabric observability-lab.yaml.
The agents say there is no network.	Deploy a network (Part 2, Step 3) and wait until it is ready.
The KPI agent finds no throughput data.	Check that your network has a monitoring edge with the kpm-sm profile, that the UE is connected, and create traffic with brc test throughput.
Still stuck?	Contact BubbleRAN customer support through your usual support channel.

Keep the fabric running. You need it in the next labs, and Lab 4 explains how to remove it.

What you learned

• A blueprint is a set of agents, and its CompositionModel is the catalog you pick them from, as <model>/<mode>.
• brc install model installs a blueprint's catalog in your cluster.
• An AIFabric picks agents, connects them to an LLM and to MCP servers, and gives one of them the supervisor role.
• You can compose your own blueprint by combining agents from other blueprints, here Supervisor and Observability. The agent catalog lists the agents you can pick from.
• The telemetry part sends the agents' traces to Phoenix, so that you can see what they did.
• brc install aifabric deploys the fabric, and MX-UI shows its status and lets you chat with every agent.