hypertic 0.0.4

The fastest and easiest way to build AI agent applications

Hypertic is the fastest and easiest way to build AI agent applications. It provides a clean, simple interface for connecting models, tools, vector databases, memory, and more.

Key Features:

1. Tools: Create custom tools with Python functions or connect to MCP servers
2. Memory: Store conversation history with in-memory, PostgreSQL, MongoDB, or Redis backends
3. Retriever: Connect agent to your documents and data for RAG capabilities
4. Structured Output: Get validated, structured responses using Pydantic models or schemas
5. Guardrails: Add safety and validation rules to control agent behavior

Check out the examples to see how Hypertic works, and visit our documentation to learn more.

Get Started

To get started, set up your Python environment (Python 3.10 or newer required), and then install the Hypertic package.

venv

python -m venv .venv
source .venv/bin/activate  # On Windows: .venv\Scripts\activate
pip install hypertic

For specific model providers, install the corresponding packages:

pip install hypertic[openai]          # For OpenAI
pip install hypertic[anthropic]       # For Anthropic
pip install hypertic[google-genai]    # For Google Gemini

uv

If you're familiar with uv, installing the package would be even easier:

uv init
uv add hypertic

For specific model providers:

uv add openai          # For OpenAI
uv add anthropic       # For Anthropic
uv add google-genai    # For Google Gemini

Quick Start

Sync (non-streaming):

Use run() for synchronous, non-streaming responses. This returns the complete response after the agent finishes processing:

from hypertic.agents import Agent
from hypertic.models import OpenAIChat
from hypertic.tools import tool

# Define a tool
@tool
def get_weather(city: str) -> str:
    """Get weather for a given city."""
    return f"Sunny, 72°F in {city}"

# Create agent
model = OpenAIChat(model="gpt-4")
agent = Agent(
    model=model,
    tools=[get_weather],
    instructions="You are a helpful assistant."
)

# Use it
response = agent.run("What's the weather in San Francisco?")
print(response.content)

Sync (streaming):

Use stream() for synchronous streaming. This yields events in real-time as the agent generates responses, improving user experience for longer outputs:

from hypertic.agents import Agent
from hypertic.models import OpenAIChat
from hypertic.tools import tool

# Define a tool
@tool
def get_weather(city: str) -> str:
    """Get weather for a given city."""
    return f"Sunny, 72°F in {city}"

# Create agent
model = OpenAIChat(model="gpt-4")
agent = Agent(
    model=model,
    tools=[get_weather],
    instructions="You are a helpful assistant."
)

# Stream responses in real-time
for event in agent.stream("What's the weather in San Francisco?"):
    if event.type == "content":
        print(event.content, end="", flush=True)

Async (non-streaming):

Use arun() for asynchronous, non-streaming responses. This is ideal for concurrent operations and non-blocking I/O:

import asyncio
from hypertic.agents import Agent
from hypertic.models import OpenAIChat
from hypertic.tools import tool

# Define a tool
@tool
def get_weather(city: str) -> str:
    """Get weather for a given city."""
    return f"Sunny, 72°F in {city}"

# Create agent
model = OpenAIChat(model="gpt-4")
agent = Agent(
    model=model,
    tools=[get_weather],
    instructions="You are a helpful assistant."
)

async def main():
    response = await agent.arun("What's the weather in San Francisco?")
    print(response.content)

asyncio.run(main())

Async (streaming):

Use astream() for asynchronous streaming. This combines the benefits of async operations with real-time response streaming:

import asyncio
from hypertic.agents import Agent
from hypertic.models import OpenAIChat
from hypertic.tools import tool

# Define a tool
@tool
def get_weather(city: str) -> str:
    """Get weather for a given city."""
    return f"Sunny, 72°F in {city}"

# Create agent
model = OpenAIChat(model="gpt-4")
agent = Agent(
    model=model,
    tools=[get_weather],
    instructions="You are a helpful assistant."
)

async def main():
    async for event in agent.astream("What's the weather in San Francisco?"):
        if event.type == "content":
            print(event.content, end="", flush=True)

asyncio.run(main())

Contributing

Contributions are welcome! Please see our Contributing Guide for details.

License

This project is licensed under the Apache License 2.0.