Skip to main content
This guide walks you through the process of creating, configuring, and deploying your first agentic application using the Backbase Agentic Platform.

​
Prerequisites

Before you begin, ensure you have:
  • Completed the Onboarding steps.
  • Access to the Self-Service repository.
  • Access to the Applications Live repository.

​
Step 1: Create a New Repository

Use the Self-Service GitOps workflow to provision a new repository based on the standard Agno template.
  1. Clone the Self-Service repository.
  2. Create a new branch (e.g., feat/my-first-agent).
  3. Open self-service.tfvars and add your new repository definition under the repositories block:
repositories = {
  # ... existing repos ...
  
  my_first_agent = {
    description = "My first agentic application"
    enable_branch_protection = true
    protected_branches = ["main", "develop"]
    
    # Use the Agno Base Template
    repository_template = {
      owner      = "bb-ecos-agbs"
      repository = "starter-agent-template-agno"
    }
  }
}
  1. Commit your changes and push the branch.
  2. Open a Pull Request (PR) and merge it after approval.
  3. The platform will automatically provision your new repository with the template contents, CI/CD pipelines, and branch protection rules.

​
Step 2: Project Setup & Features

Once your repository is provisioned, clone it to your local machine. The template automatically sets up:
  • Assistant Agent: A basic agent implementation in src/agents.
  • API Server: FastAPI application in src/api serving the agent.
  • BB AI SDK: Pre-configured SDK for AI Gateway and Observability.
  • AI Gateway: Integrated via bb-ai-sdk for secure model access.
  • Observability: Hooks for Langfuse/LangWatch via bb-ai-sdk.
  • CI/CD Pipelines: GitHub Actions for linting, testing, publishing, and provisioning (see CI/CD Workflows).

​
Setup and Run Locally

  1. Clone the repository:
git clone https://github.com/your-org/my-first-agent.git
cd my-first-agent
  1. Create virtual environment:
uv venv --python 3.12
source .venv/bin/activate  # macOS/Linux
# or .venv\Scripts\activate  # Windows
  1. Copy environment template:
cp env.template .env
  1. Configure credentials - Edit .env with required values:
# Required - Artifactory credentials (for bb-ai-sdk)
UV_INDEX_BACKBASE_USERNAME[email protected]
UV_INDEX_BACKBASE_PASSWORD=your-artifactory-token

# AI Gateway
AI_GATEWAY_ENDPOINT=ai-gateway-endpoint
AI_GATEWAY_API_KEY=your-api-key

# Observability - Langfuse
LANGFUSE_PUBLIC_KEY=pk-lf-...
LANGFUSE_SECRET_KEY=sk-lf-...
LANGFUSE_HOST=langfuse-endpoint

# Server Config
HOST=0.0.0.0
PORT=8000
DEBUG=true

# Web Proxy (Required for local dev)
HTTP_PROXY=http://webproxy.infra.backbase.cloud:8888
HTTPS_PROXY=http://webproxy.infra.backbase.cloud:8888
NO_PROXY=localhost,127.0.0.1
  1. Install dependencies and run:
# Export env vars (Linux/macOS) to authenticate with Artifactory
export $(cat .env | grep -v '^#' | xargs) && uv sync

# Run the server
uv run python -m src.main
VPN and Web Proxy: Required for local development. Configure Aviatrix VPN and web proxy settings. See Onboarding Guide for setup instructions.
Test the local API: 
curl -X POST http://localhost:8000/run \
  -H "Content-Type: application/json" \
  -d '{"input":"Say hello"}'

​
Step 3: Configure Environment

The environment configuration is already set up in Step 2. This section provides additional context about environment variables used by the SDK.
The bb-ai-sdk uses these environment variables:
  • AI Gateway: AI_GATEWAY_ENDPOINT, AI_GATEWAY_API_KEY
  • Observability: LANGFUSE_PUBLIC_KEY, LANGFUSE_SECRET_KEY, LANGFUSE_HOST
For SDK usage patterns (AI Gateway client, observability initialization), see BB AI SDK Get Started.

​
Step 4: Deploy to Runtime

Deploying your agent involves building a Docker image and updating the Applications Live repository to run it.

​
1. Build and Publish Image

The CI/CD pipeline automatically builds and publishes a Docker image to the container registry when you merge to main or publish a release.

​
2. Update Applications Live

  1. Clone the Applications Live repository.
  2. Navigate to your runtime environment folder (e.g., dev/).
  3. Create or update the values file for your application (e.g., my-first-agent.yaml):
image:
  repository: backbase.azurecr.io/my-first-agent
  tag: v0.1.0

resources:
  limits:
    cpu: 500m
    memory: 512Mi
  requests:
    cpu: 200m
    memory: 256Mi

env:
  AI_GATEWAY_ENDPOINT: "https://ai-gateway.backbase.cloud"
  # Secrets should be referenced from Kubernetes secrets - generated via SOPS
  1. Commit, push, and merge the PR. ArgoCD will sync the changes and deploy your agent to the namespace.
Need the runtime folder structure or PR reviewers? Check the Applications Live repo conventions (default reviewers, overrides, and auto-approve) as described in Self Service.

​
Step 5: Expose via APIM

To access your agent’s API from outside the cluster, you need to expose it via API Management (APIM).
  1. In the Applications Live repository, locate the APIM configuration section.
  2. Define an API definition for your agent:
apiVersion: apim.backbase.com/v1
kind: API
metadata:
  name: my-first-agent
spec:
  path: /v1
  serviceUrl: http://my-first-agent.backbase.svc.cluster.local:8080
  openApiSpec: ./openapi.yaml
  1. Merge the changes.
  2. Your agent is now accessible at https://api.dev.backbase.cloud/v1.
Test the deployed API through APIM: 
curl -X POST "https://api.dev.backbase.cloud/v1/run" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <token>" \
  -d '{"input":"Say hello"}'
You have successfully created, deployed, and exposed your first agentic application!