SDK-First Integration

Infrastructure is most useful when teams can adopt it without rewriting the application that already works. That is the goal behind Alchymos SDKs: add caching and visibility around existing clients while keeping the integration small, explicit, and familiar.

Wrap the client you already use

The SDK approach lets teams connect Alchymos to existing OpenAI, MCP, and Vercel AI workflows. The application keeps its current client configuration and request shape, while the wrapper adds the cache and telemetry behavior around the call.

This boundary is intentional. The SDK should make the infrastructure available without forcing a new orchestration framework or a new provider abstraction into the application.

Type-safe by default

Alchymos is designed for modern TypeScript environments with first-class types and editor support. Configuration and request options should be discoverable in the same development environment as the rest of the agent, so teams can move from a first integration to more precise cache rules without losing feedback from the compiler.

Control without configuration sprawl

A useful SDK should provide sensible defaults and still expose the controls advanced workloads need. Cache TTLs, scopes, tags, and invalidation behavior can be configured when the workflow requires them, while simple integrations can start with minimal setup.

The same principle applies to observability. Telemetry should be available as part of the request path, not as a separate project that engineers have to assemble before they can understand a cache hit or miss.

OpenAI, MCP, and Vercel AI

Agent stacks are not uniform. Some teams start with an OpenAI client, others build around MCP tools, and others use Vercel AI as part of a broader application. Supporting these entry points lets the same caching and observability model follow the workload instead of dictating the stack.

For MCP specifically, the integration can cover both client-side calls and server-side tool execution. That makes it possible to reason about the complete path rather than only one side of the interaction.

Start small, grow deliberately

An SDK-first integration should be useful on the first day and remain understandable as the system grows. Teams can begin by attaching Alchymos to one client, measure the resulting behavior, then add rules, scopes, and traces as they learn which parts of the workflow benefit most.

That incremental path is the core design goal: add infrastructure where it creates leverage, keep the application in control, and make every additional capability visible in code.