Skip to main content

Design Principles Behind the Agents SDK

The Agents SDK is designed to provide a flexible, scalable, and efficient framework for building, testing, and deploying LLM agents. This article discusses the key design principles and goals that guided the development of the SDK.

High-Level Goals​

The primary goals of the Agents SDK are:

  1. Speed of Development: Allow developers to build agents faster by providing a set of tools and abstractions that simplify the development process.
  2. Local Debugging: Enable developers to debug agents in a local environment, reducing the need for extensive logging in production code.
  3. External Developer Support: Allow external developers to build agents that can be integrated into the Zeta Alpha platform.
  4. Unopinionated Interface: Provide a flexible interface that supports various frameworks and styles.
  5. Automatic Dependency Injection: Simplify the development process by automatically injecting necessary dependencies and configurations.
  6. Seamless Transition to Production: Ensure that the same codebase used in the local environment can be seamlessly transitioned to production, minimizing discrepancies and simplifying deployment.

Key Design Principles​

1. Modularity​

The SDK is designed to be modular, allowing developers to build agents using a combination of built-in and custom components. This modularity is achieved through the use of interfaces and dependency injection.

  • Interfaces: The SDK defines a set of interfaces (e.g., ChatAgent, StreamableChatAgent, AgentDependencyFactory) that developers can implement to create custom agents and dependencies.
  • Dependency Injection: The SDK uses dependency injection to automatically inject dependencies into agents at runtime, allowing developers to focus on building the core logic of their agents without worrying about how dependencies are wired together. This also facilitates testing by enabling easy mocking of dependencies.

2. Flexibility​

The SDK provides a flexible interface that allows developers to build agents in any framework or style they prefer. This flexibility is achieved through:

  • Unopinionated Interface: The SDK exposes an unopinionated interface that allows developers to build agents using any framework or style they prefer.
  • Framework Support: Built-in support for popular frameworks like LangChain makes it easy to integrate existing solutions into the SDK.

3. Reusability​

The SDK promotes code reusability, allowing developers to use the same codebase for agents in multiple environments. This is achieved through:

  • Configuration System: Existing agents can be configured at runtime through a plugable configuration system, allowing developers to reuse the same agent logic with different configurations.
  • Dependency Injection: Automatic dependency injection allows using existing agents and dependencies in new agents, promoting code reuse and reducing duplication.

4. Ease of Debugging and Evaluation​

The SDK is designed to make debugging and evaluation straightforward, enabling developers to debug agents locally and evaluate their performance using integrated tools.

  • Local Debugging UI: A local debugging UI allows developers to interact with agents, override configurations, and see real-time changes, making it easy to debug agents without extensive logging in production code.
  • RAGElo Integration: The SDK integrates with the RAGElo tool, allowing developers to evaluate the quality of their agents' responses. This integration enables developers to compare different agents and configurations, ensuring that the best-performing agents are deployed to production.

5. Extensibility​

The SDK is designed to be extensible, allowing developers to add new features and functionality as needed. This extensibility is achieved through:

  • Plugin System: A plugin system allows developers to add new features and functionality to the SDK without modifying the core codebase.
  • Custom Components: Support for custom components enables developers to build and integrate their own components into the SDK.

6. Production Readiness​

The SDK ensures that agents are production-ready, with features that support deployment in various environments. This is achieved through:

  • Zeta Alpha Enterprise Platform: Agents can be deployed inside the Zeta Alpha platform, leveraging its robust infrastructure and capabilities.
  • Self-Hosted Model: The SDK supports a self-hosted model, allowing agents to be deployed on the developer's own infrastructure. This model supports multiple deployment options and configurations, providing flexibility to meet different operational requirements.
  • LLMOps Integration: Integration with LLMOps solutions provides tracing and monitoring capabilities for agents in production, allowing developers to track performance, identify issues, and make improvements.