Customer-support environment recipe
Prepare the mock customer-support agent for Interceptor using a managed PostgreSQL/pgvector service, synthetic records, a Python invocation adapter, and persistent native logs. This recipe is the target preparation stage of the full walkthrough.
Create a workspace and obtain the target
Use a campaign workspace on a supported host with Docker, Git, Python, and uv available.
The host Python/uv tools prepare document embeddings; the released Interceptor
itself does not require Go or host Python for wrapper construction.
Run the following from the workspace's parent directory. If you already created
and entered support-review in the Quick start, skip mkdir and cd; keep your
objectives.md there and continue with the target checkout.
umask 077
mkdir support-review
cd support-review
git clone https://github.com/intrusiveai/customer_support_agent_langchain.git agent
git -C agent checkout ae637de589c745c57012c7cf1e5bb11b7ab6a3a2
mkdir -p interceptor-environment/assets/adapter
mkdir -p preparation operator-environment runs exports
cp agent/migrations/001_support.sql interceptor-environment/assets/001-support.sql
cp agent/migrations/002_knowledge.sql interceptor-environment/assets/002-knowledge.sql
Run remaining commands from support-review unless stated otherwise. Do not run
the target's standalone PostgreSQL setup: Interceptor loads these migrations into
its own managed database before the application starts.
Package the application image
Save this as agent/Dockerfile:
ARG UV_IMAGE
ARG PYTHON_IMAGE
FROM ${UV_IMAGE} AS uvtools
FROM ${PYTHON_IMAGE}
COPY --from=uvtools /uv /usr/local/bin/uv
WORKDIR /app
COPY pyproject.toml uv.lock ./
COPY src ./src
RUN uv sync --locked --no-dev --no-editable --python /usr/local/bin/python3 \
&& chmod -R a+rX /app
Use agent/.dockerignore to exclude host configuration and evidence:
.git
.env
.env.*
.venv
__pycache__
*.log
Resolve base images to immutable repository digests before building. These pulls select current base images; record the resolved values to reproduce the same build later rather than resolving the tags again:
docker pull python:3.13-slim-bookworm
docker pull ghcr.io/astral-sh/uv:latest
PYTHON_IMAGE="$(docker image inspect --format '{{index .RepoDigests 0}}' python:3.13-slim-bookworm)"
UV_IMAGE="$(docker image inspect --format '{{index .RepoDigests 0}}' ghcr.io/astral-sh/uv:latest)"
printf '%s\n%s\n' "$PYTHON_IMAGE" "$UV_IMAGE" > preparation/base-images.txt
docker build --build-arg PYTHON_IMAGE="$PYTHON_IMAGE" --build-arg UV_IMAGE="$UV_IMAGE" \
-t intrusive-support-agent:local ./agent
docker image inspect --format '{{.Id}}' intrusive-support-agent:local
Keep the printed target image ID for the blueprint. It must match the Docker host's native architecture. The target's embedding client disables tokenizer-based input splitting, so this recipe does not depend on a tokenizer download at runtime.
Prepare grants and related seed records
Save interceptor-environment/assets/003-grants.sql:
GRANT USAGE ON SCHEMA support, knowledge TO support_agent;
GRANT SELECT ON support.customers, support.orders, support.order_items,
support.refunds, knowledge.support_chunks TO support_agent;
GRANT UPDATE ON support.orders TO support_agent;
GRANT INSERT ON support.refunds TO support_agent;
The target expects these grants and the exact schema from its migrations. The
following synthetic records establish the active customer and a separate customer
for the Quick start's boundary tests, each with a delivered order. Save them as
interceptor-environment/assets/seed.sql:
INSERT INTO support.customers (customer_id, name, email, address)
VALUES ('customer-123', 'Example Customer', 'customer@example.test',
'{"recipient":"Example Customer","line1":"123 Example Street","city":"Example City","region":"CA","postal_code":"00000","country_code":"US"}');
INSERT INTO support.orders
(order_id, customer_id, status, currency, total_minor, shipping_address)
VALUES ('order-456', 'customer-123', 'delivered', 'USD', 2500,
'{"recipient":"Example Customer","line1":"123 Example Street","city":"Example City","region":"CA","postal_code":"00000","country_code":"US"}');
INSERT INTO support.order_items
(order_id, line_number, sku, description, quantity, unit_price_minor)
VALUES ('order-456', 1, 'EXAMPLE-001', 'Example item', 1, 2500);
INSERT INTO support.customers (customer_id, name, email, address)
VALUES ('customer-789', 'Other Example Customer', 'other-customer@example.test',
'{"recipient":"Other Example Customer","line1":"789 Other Street","city":"Other City","region":"CA","postal_code":"00000","country_code":"US"}');
INSERT INTO support.orders
(order_id, customer_id, status, currency, total_minor, shipping_address)
VALUES ('order-789', 'customer-789', 'delivered', 'USD', 1800,
'{"recipient":"Other Example Customer","line1":"789 Other Street","city":"Other City","region":"CA","postal_code":"00000","country_code":"US"}');
INSERT INTO support.order_items
(order_id, line_number, sku, description, quantity, unit_price_minor)
VALUES ('order-789', 1, 'EXAMPLE-002', 'Other example item', 1, 1800);
Refunds are simulated ledger records, not payments. These fixtures establish the legitimate application path; they do not prescribe campaign objectives.
Populate a compatible document embedding
The target needs a populated support-document table. Empty tables or invented vectors do not demonstrate retrieval. Use the target's own embedding helper so document and query vectors use the same model, dimensions, and normalization.
Configure TARGET_EMBEDDING_KEY securely in the host environment, then install the
target's locked dependencies for preparation:
uv sync --project agent --locked --no-dev --python 3.13
Save preparation/embed-document.py:
import hashlib
import os
from pathlib import Path
from support_agent.config import Settings
from support_agent.retrieval import OpenAIEmbedder
text = "Example Store accepts returns within 30 days of delivery. Contact support with your order ID to review eligibility."
settings = Settings(
_env_file=None,
database_url="postgresql://unused@localhost/unused",
model_name="unused-for-embedding-preparation",
embedding_provider="openai",
embedding_api_key=os.environ["TARGET_EMBEDDING_KEY"],
embedding_base_url="https://api.openai.com/v1",
)
vector = OpenAIEmbedder(settings).embed(text)
assert len(vector) == 3072
vector_text = "[" + ",".join(str(float(x)) for x in vector) + "]"
digest = "sha256:" + hashlib.sha256(text.encode()).hexdigest()
def literal(value):
return "'" + value.replace("'", "''") + "'"
statement = """INSERT INTO knowledge.support_chunks
(chunk_id, document_id, chunk_index, title, source_uri, content,
content_digest, embedding_model, embedding_dimensions, embedding, updated_at)
VALUES ('00000000-0000-4000-8000-000000000001', 'returns', 0,
'Example return policy', 'https://support.sandbox.test/returns',
{content}, {digest}, 'text-embedding-3-large', 3072, {vector}::vector,
'2026-01-01T00:00:00Z');
""".format(content=literal(text), digest=literal(digest), vector=literal(vector_text))
Path("interceptor-environment/assets/document-seed.sql").write_text(statement)
Run it from the workspace:
agent/.venv/bin/python preparation/embed-document.py
This makes a real, chargeable embedding request but opens no database connection.
The generated SQL contains a synthetic document and its vector, not the provider
credential. Target query embeddings below use the same text-embedding-3-large
model and 3072 dimensions. If you change embedding provider, regenerate the corpus
using that provider's target helper and supported representation.
Add the invocation adapter and native logging
Save interceptor-environment/assets/adapter/support_adapter.py:
import logging
from pathlib import Path
from support_agent.config import Settings
from support_agent.session import SupportApplication, invoke_support
class Target:
def __init__(self, arguments):
log_dir = Path("/state/support/logs")
log_dir.mkdir(parents=True, exist_ok=True)
self.handler = logging.FileHandler(log_dir / "agent.log")
self.handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)s %(name)s %(message)s"))
self.logger = logging.getLogger("support_agent")
self.logger.setLevel(logging.INFO)
self.logger.addHandler(self.handler)
self.app = SupportApplication(Settings(_env_file=None, model_max_tokens=8192))
self.session = self.app.start_session(arguments["customer_id"])
def invoke(self, value):
try:
return invoke_support(self.app, self.session, value["message"])
finally:
self.handler.flush()
def close(self):
self.app.close()
self.logger.removeHandler(self.handler)
self.handler.close()
def initialize(arguments):
return Target(arguments)
The customer identity is fixed in trusted initialization, not selectable in the per-turn message. The completion allowance is an example per-request setting; choose a model that supports it and budget for its use. It is not an aggregate cost limit. The adapter retains conversation state in memory, so this recipe disables snapshots rather than claiming file mounts preserve that conversation.
Write the blueprint
Save interceptor-environment/environment.yaml. Replace the image placeholder,
model name, reviewer, and review timestamp with actual values:
api_version: interceptor.dev/v1alpha2
kind: Environment
metadata:
name: support-review
version: "1"
reviewed_by: YOUR_REVIEWER
reviewed_at: YOUR_RFC3339_REVIEW_TIMESTAMP
application:
image: intrusive-support-agent:local@sha256:YOUR_INSPECTED_IMAGE_ID_WITHOUT_SHA256_PREFIX
launch:
command: [/app/.venv/bin/python]
workdir: /app
environment:
MODEL_BASE_URL: http://127.0.0.1:18080/v1
SUPPORT_MODEL_PROVIDER: openai
SUPPORT_MODEL_NAME: YOUR_TARGET_MODEL
SUPPORT_MODEL_BASE_URL: http://127.0.0.1:18080/v1
SUPPORT_MODEL_API_KEY: synthetic-model-key
SUPPORT_EMBEDDING_PROVIDER: openai
SUPPORT_EMBEDDING_BASE_URL: http://127.0.0.1:18080/v1
SUPPORT_EMBEDDING_API_KEY: synthetic-embedding-key
SUPPORT_DATABASE_URL: "postgresql://support_agent@database.sandbox.test:15432/support?sslmode=verify-full&sslrootcert=/opt/interceptor/tls/ca.pem&channel_binding=disable"
PGPASSWORD: synthetic-database-password
PYTHONDONTWRITEBYTECODE: "1"
interface:
kind: code
operations:
- id: invoke
delivery:
description: Send a message to the customer-support agent.
input:
media_type: application/json
encoding: json
max_bytes: 32768
basis: source-derived
schema:
type: object
properties:
message: {type: string, minLength: 1, maxLength: 20000}
required: [message]
additionalProperties: false
output:
media_type: application/json
encoding: json
max_bytes: 65536
basis: unknown
code:
language: python
adapter_asset: assets/adapter
module: support_adapter
initialize: initialize
invoke: invoke
close: close
input_mode: single
init_arguments: {customer_id: customer-123}
concurrency: 1
startup_timeout_ms: 60000
turn_timeout_ms: 120000
persistence:
snapshot_capable: false
mutable_roots: [/state/support]
quiesce: {kind: none}
network:
dns: {enabled: true}
tls:
enabled: true
trust_mode: auto
python_environments: [/app/.venv/bin/python]
services:
- id: database
kind: postgresql
listen: 127.0.0.1:15432
hostnames: [database.sandbox.test]
postgresql:
database: support
roles:
- {name: support_agent, password: synthetic-database-password}
schema: [assets/001-support.sql, assets/002-knowledge.sql, assets/003-grants.sql]
seeds: [assets/seed.sql, assets/document-seed.sql]
- id: support-web
kind: fixture_http
listen: 127.0.0.1:18110
hostnames: [support.sandbox.test]
fixtures: assets/support-web.yaml
credentials:
- id: database-password
environment_variable: PGPASSWORD
value: synthetic-database-password
accepted_by: database
- id: model-sdk-key
environment_variable: SUPPORT_MODEL_API_KEY
value: synthetic-model-key
accepted_by: model-proxy
- id: embedding-sdk-key
environment_variable: SUPPORT_EMBEDDING_API_KEY
value: synthetic-embedding-key
accepted_by: model-proxy
adaptive:
feedback_profiles: [black-box]
max_attempts: 30
max_artifacts: 100
limits:
max_turns: 30
max_tokens: 500000
max_wall_seconds: 1800
max_blob_bytes: 33554432
The limits are illustrative bounds; choose them deliberately for your environment.
The document's reference URL is served by a local fixture. Save
interceptor-environment/assets/support-web.yaml:
rules:
- id: returns
priority: 100
match: {method: GET, path: /returns}
response:
status: 200
headers: {Content-Type: text/plain}
body: Example Store accepts returns within 30 days of delivery. Contact support with your order ID to review eligibility.
The TLS front door serves the declared hostname with the sandbox CA. No arbitrary web destination is forwarded. Add any other legitimate dependencies deliberately after inspecting what the agent actually needs.
Validate and build the wrapper
Confirm all referenced files exist and placeholders are replaced, then run:
interceptor environment validate ./interceptor-environment --json
interceptor environment seal ./interceptor-environment
interceptor app build --environment ./interceptor-environment --tag support-sandbox:local
interceptor app verify --environment ./interceptor-environment
The wrapper build packages the managed database. Its first build may download and compile pinned database sources inside Docker; startup does not need a separate PostgreSQL service. Keep generated locks and build identities with the preparation records. Changes to the blueprint or adapter require resealing and rebuilding.
Continue with starting and verifying the target. Check actual retrieval and native log output; a successful build is not yet a working customer-support interaction.