AgentPress is a collection of simple, but powerful utilities that serve as building blocks for creating AI agents. Plug, play, and customize.
- Threads: Simple message thread handling utilities
- Tools: Flexible tool definition and automatic execution
- State Management: Simple JSON key-value state management
- LLM Integration: Provider-agnostic LLM calls via LiteLLM
- Install the package:
pip install agentpress- Initialize AgentPress in your project:
agentpress initCreates a agentpress directory with all the core utilities.
Check out File Overview for explanations of the generated util files.
- If you selected the example agent during initialization:
- Creates an
agent.pyfile with a web development agent example - Creates a
toolsdirectory with example tools:files_tool.py: File operations (create/update files, read directory and load into state)terminal_tool.py: Terminal command execution
- Creates a
workspacedirectory for the agent to work in
- Creates an
- Set up your environment variables (API keys, etc.) in a
.envfile.
- OPENAI_API_KEY, ANTHROPIC_API_KEY, GROQ_API_KEY, etc... Whatever LLM you want to use, we use LiteLLM (https://litellm.ai) (Call 100+ LLMs using the OpenAI Input/Output Format) – set it up in your
.envfile.. Also check out the agentpress/llm.py and modify as needed to support your wanted LLM.
- Create a calculator_tool.py
from agentpress.tool import Tool, ToolResult, tool_schema
class CalculatorTool(Tool):
@tool_schema({
"name": "add",
"description": "Add two numbers",
"parameters": {
"type": "object",
"properties": {
"a": {"type": "number"},
"b": {"type": "number"}
},
"required": ["a", "b"]
}
})
async def add(self, a: float, b: float) -> ToolResult:
try:
result = a + b
return self.success_response(f"The sum is {result}")
except Exception as e:
return self.fail_response(f"Failed to add numbers: {str(e)}")- Use the Thread Manager, create a new thread – or access an existing one. Then Add the Calculator Tool, and run the thread. It will automatically use & execute the python function associated with the tool:
import asyncio
from agentpress.thread_manager import ThreadManager
from calculator_tool import CalculatorTool
async def main():
# Initialize thread manager and add tools
manager = ThreadManager()
manager.add_tool(CalculatorTool)
# Create a new thread
# Alternatively, you could use an existing thread_id like:
# thread_id = "existing-thread-uuid"
thread_id = await manager.create_thread()
# Add your custom logic here
await manager.add_message(thread_id, {
"role": "user",
"content": "What's 2 + 2?"
})
response = await manager.run_thread(
thread_id=thread_id,
system_message={
"role": "system",
"content": "You are a helpful assistant with calculation abilities."
},
model_name="gpt-4",
use_tools=True,
execute_model_tool_calls=True
)
print("Response:", response)
asyncio.run(main())- Autonomous Web Developer Agent (the standard example)
When you run agentpress init and select the example agent – you will get code for a simple implementation of an AI Web Developer Agent that leverages architecture similar to platforms like our own Softgen Platform.
- Files Tool: Allows the agent to create, read, update, and delete files within the workspace.
- Terminal Tool: Enables the agent to execute terminal commands.
- State Workspace Management: The agent has access to a workspace whose state is stored and sent on every request. This state includes all file contents, ensuring the agent knows what it is editing.
- User Interaction via CLI: After each action, the agent pauses and allows the user to provide further instructions through the CLI.
You can find the complete implementation in our example-agent directory.
- Thread Viewer
Run the thread viewer to view messages of threads in a stylised web UI:
streamlit run agentpress/thread_viewer_ui.pyCore LLM API interface using LiteLLM. Supports 100+ LLMs using the OpenAI Input/Output Format. Easy to extend for custom model configurations and API endpoints. make_llm_api_call() can be imported to make LLM calls.
Orchestrates conversations between users, LLMs, and tools. Manages message history and automatically handles tool execution when LLMs request them. Tools registered here become available for LLM function calls.
Base infrastructure for LLM-compatible tools. Inherit from Tool class and use @tool_schema decorator to create tools that are automatically registered for LLM function calling. Returns standardized ToolResult responses.
Central registry for tool management. Keeps track of available tools and their schemas, allowing selective function registration. Works with thread_manager.py to expose tools to LLMs.
Simple key-value based state persistence using JSON files. For maintaining environment state, settings, or other persistent data.
- Plug & Play: Start with our defaults, then customize to your needs.
- Agnostic: Built on LiteLLM, supporting any LLM provider. Minimal opinions, maximum flexibility.
- Simplicity: Clean, readable code that's easy to understand and modify.
- No Lock-in: Take full ownership of the code. Copy what you need directly into your codebase.
We welcome contributions! Feel free to:
- Submit issues for bugs or suggestions
- Fork the repository and send pull requests
- Share how you've used AgentPress in your projects
- Clone:
git clone https://github.com/kortix-ai/agentpress
cd agentpress- Install dependencies:
pip install poetry
poetry install- Build the package:
poetry buildIt will return the built package name with the version number.
- Install the package with the correct version number, here for example its 0.1.3
agentpress-0.1.3-py3-none-any.whl:
pip install /Users/markokraemer/Projects/agentpress/dist/agentpress-0.1.3-py3-none-any.whl --force-reinstallThen you can test that version.
Built with ❤️ by Kortix AI Corp