Boomi Architect cheat sheet

Process shapes: start, connector, map, decision, branch, try/catch, stop, notify, and subprocess; each shape has a type and optional configuration.

Document flow: a process receives a document, caches it under a data element name, and each shape reads/writes via the cache; the final document is returned.

Connector operations are action-based (GET, POST, QUERY, EXECUTE); operation settings include request/response profiles and headers.

Decision shape evaluates a condition against the current document or a property; branches are ordered and the first true branch executes.

Try/Catch shape catches connector or map exceptions; the catch path receives the error document with message, stack trace, and original document if configured.

Subprocess call is synchronous and shares the parent process's document cache; it is not a separate execution thread and cannot run in parallel by itself.

Scheduling: a process schedule can be interval, cron, or event-driven; scheduled processes run in the Boomi runtime and are subject to atom/cloud limits.

Error handling rule: unhandled exceptions in a process mark the execution as ERROR and are logged; use a Notify shape or process reporting to alert.

Retry logic: connector-level retry is not universal; implement retry with a loop + decision + delay or use the platform's retry settings where available.

API component types: API endpoint (REST/SOAP), API service (operation group), API proxy (front-end to back-end), and API gateway (runtime).

API Service component groups operations and binds them to processes; each operation maps to a process and an HTTP method/path.

API Proxy component defines a front-end path and routes to a back-end service or URL; it supports policies and authentication at the gateway.

Authentication options: API key, OAuth 2.0 (client credentials, authorization code), Basic, and JWT validation; policies are applied per API or per operation.

Rate limiting and quotas are configured as policies on the API; they are enforced by the gateway, not by the process.

API versioning: use distinct API component versions or path prefixes; changing an operation signature requires a new version to avoid breaking consumers.

Gateway deployment: an API must be deployed to a gateway (cloud or atom) before it is reachable; deployment includes the API component and its dependencies.

CORS and header policies are gateway-level; they do not require process changes.

API documentation is generated from the API component definition; OpenAPI import/export is supported for REST APIs.

Profiles: XML, JSON, flat file (delimited/fixed), database, EDI, and custom; a profile defines the structure of a document for mapping.

Map shape: source profile to target profile; mappings can be direct, defaulted, or conditional; functions transform values.

Common map functions: string (concat, substring, replace), numeric (add, multiply), date (format, parse), lookup (table lookup), and scripting (Groovy/JavaScript).

Document cache: each document in a process is stored under a unique data element name; map source/target reference these names.

Data process shape: used for extract/transform/load without a connector; it reads from a source profile and writes to a target profile.

Flat file options: delimiter, qualifier, header row, and fixed-width column definitions must match the actual file; mismatches cause parse errors.

JSON profile: root element, arrays, and nested objects; use the JSON profile wizard to generate from a sample.

Database connector: operation types include SELECT, INSERT, UPDATE, DELETE, and stored procedure; use a database profile for the result set.

Data validation: use a map with required fields and default values; validation errors surface as map exceptions.

AI connectors in Boomi expose model providers (e.g., OpenAI, Azure OpenAI, Bedrock) as connector operations; each operation has request/response profiles.

Model invocation pattern: connector operation -> prompt document -> model response document -> map to target profile.

Prompt construction: use a map or scripting shape to assemble system/user messages; store prompts in a profile for reusability.

Token limits: each model has a context window; long prompts or documents must be chunked before invocation.

Embeddings: an embedding operation returns a vector; store vectors in a vector database or Boomi Data Hub for retrieval.

Retrieval-augmented generation (RAG): embed query -> similarity search -> inject retrieved chunks into prompt -> invoke model.

Secrets: API keys for AI providers are stored in Boomi secrets/environment extensions, not hard-coded in processes.

Error handling: model calls can time out or rate-limit; use try/catch and retry with backoff.

Cost control: batch requests where possible and monitor token usage via connector logs.

Agent = model + tools + memory + orchestration loop; in Boomi, tools are processes or API operations exposed to the agent.

Tool definition: each tool has a name, description, input schema, and output schema; the model selects tools based on description and schema.

Orchestration loop: observe -> decide -> act (tool call) -> observe result -> repeat until a stop condition or max iterations.

Memory: short-term (conversation context in the prompt) and long-term (vector store or database); Boomi processes manage both.

Guardrails: validate tool inputs/outputs, restrict tool permissions, and set max iterations to prevent runaway loops.

Human-in-the-loop: insert an approval step (e.g., a process that waits for a decision) before high-impact tool calls.

Observability: log each tool call, model response, and decision; correlate with a conversation or run ID.

Failure modes: hallucinated tool names, invalid arguments, and infinite loops; handle with schema validation and iteration caps.

Security: apply least-privilege to tools and authenticate the agent to downstream systems via Boomi secrets.