An Agent Engineering Blueprint powered by Pixeltable
View the source code and contribute to Pixelagent
We see agents as the intersection of an LLM, storage, and orchestration. Pixeltable unifies this interface into a single declarative framework, making it the de-facto choice for engineers to build custom agentic applications with build-your-own functionality for memory, tool-calling, and more.
Pixelagent is more than just another agent framework—it’s a comprehensive guide to building production-grade agent systems from the ground up. With our blueprint approach, you’ll learn the engineering patterns behind successful agent architectures while leveraging Pixeltable’s powerful data management capabilities to handle the complex infrastructure needs.
We start with fundamental patterns and gradually introduce complexity, allowing you to understand every aspect of agent construction:
Agent()
classLearn how we craft an agent using Claude, with cost-saving tricks like skipping chat history in tool calls
See how we use GPT models to create a lean, powerful agent with the same Pixeltable-driven efficiency
The foundation of our blueprint begins with creating a simple yet powerful Agent class for a single LLM provider. This initial step focuses on establishing core functionality like conversation handling, memory management, and basic tool integration. By starting with a single provider, you’ll learn the fundamental patterns that can later be extended to support additional LLM services.
The Agent() class is built on three core components:
Agent()
to multiple providersOnce you’ve mastered building an agent for a single LLM provider, the next step is extending your architecture to support multiple providers. This progression is crucial for production systems that need flexibility to switch between different LLM services based on capabilities, cost, or availability. Our blueprint demonstrates a clean, inheritance-based approach to achieve this multi-provider support without duplicating code.
By implementing a BaseAgent abstract class that handles common functionality, you can create specialized provider-specific implementations that override only what’s unique to each provider. This architecture allows you to maintain a consistent interface while adapting to the nuances of different LLM APIs.
Learn how to extend the Agent class to support multiple LLM providers
With a solid agent foundation in place, the final step is adding specialized capabilities that transform a basic conversational agent into a sophisticated AI system. Our blueprint includes detailed implementations of the most important agentic patterns, each designed as modular extensions that can be mixed and matched based on your specific requirements.
These extensions leverage Pixeltable’s data management capabilities to implement complex features like long-term memory, reflection loops, and multi-step reasoning—all while maintaining a clean, maintainable codebase. Each extension is explained with both theoretical background and practical implementation details, allowing you to understand not just how to use them, but how they work under the hood.
Add custom python functions as tools to enable your agent to interact with external systems, retrieve information, and perform actions beyond just conversation.
Implement sophisticated memory systems that allow your agent to recall past interactions, store knowledge, and perform semantic search over its memory.
Add self-improvement capabilities through reflection loops where agents can evaluate their own performance and adjust their behavior accordingly.
Implement advanced reasoning patterns like ReAct and Chain-of-Thought to handle complex multi-step tasks with robust problem-solving capabilities.
Pixelagent is designed to be both powerful and approachable. Our API emphasizes clarity and simplicity, allowing you to get started quickly while still having access to advanced features when needed. The following examples demonstrate how to use Pixelagent in various scenarios, from basic conversational agents to complex systems with tools and specialized reasoning patterns.
Installation
Quick Start
Adding Tools
Access Conversation Memory
Beyond the basics, Pixelagent provides sophisticated capabilities that allow you to build production-grade agent systems. These features demonstrate the power of combining Pixeltable’s data management with advanced agent patterns, enabling you to create AI systems that can handle complex tasks, maintain context over long conversations, and adapt to changing requirements.
Unlimited Memory
ReAct Pattern
At its core, Pixelagent implements a clean, modular architecture that separates concerns while maintaining flexibility. This diagram illustrates the main components and their relationships, showing how the system integrates LLM providers, memory, tools, and orchestration into a cohesive whole.
We provide comprehensive examples and tutorials to help you get started quickly and master advanced concepts. These resources range from basic implementation guides to sophisticated patterns for specialized use cases, ensuring you have the knowledge to build exactly what you need.
Step-by-step introduction to core concepts
Explore reflection and planning techniques
Browse examples for deeper implementations
Ready to start building? Dive into the blueprints, tweak them to your needs, and let Pixeltable handle the AI data infrastructure while you focus on innovation!