BotWire FAQ: Memory, Pricing, Self-Hosting, Privacy

Free · Open source (MIT) · Works with LangChain, CrewAI, AutoGen · No signup

You're evaluating BotWire but have questions about memory persistence, pricing models, self-hosting options, or privacy implications. These concerns are blocking your adoption decision. This FAQ addresses the most common objections developers have when choosing BotWire for AI agent memory.

The Evaluation Roadblock

When building AI agents, you need persistent memory that survives restarts, works across processes, and doesn't disappear when your container gets recycled. Most developers initially try in-memory dictionaries, JSON files, or session storage — then hit the wall when their agent forgets everything between conversations.

The real pain comes when evaluating solutions. Redis requires infrastructure. Vector databases are overkill for simple key-value storage. Managed services want credit cards upfront. You need something that works immediately but scales when you're ready.

BotWire Memory solves this with a simple HTTP API for persistent agent memory, but the "too good to be true" factor raises legitimate questions about pricing sustainability, data ownership, and vendor lock-in.

The Fix

Install BotWire and get persistent memory in three lines:

pip install botwire

from botwire import Memory

# Persistent memory that survives restarts
m = Memory("my-agent")
m.set("user_preference", "dark_mode")
print(m.get("user_preference"))  # "dark_mode"

This memory persists across processes, containers, and deployments. No configuration, no API keys, no signup required.

How BotWire Memory Works

The Memory class connects to BotWire's HTTP API at https://botwire.dev. Your namespace acts as an isolated storage bucket — other developers can't access your data, even without authentication.

from botwire import Memory
import time

# Create isolated memory spaces
user_memory = Memory("user-sessions")
agent_memory = Memory("agent-state")

# Store complex data structures
user_memory.set("user-42", {
    "name": "Alice",
    "conversation_count": 5,
    "last_topic": "pricing questions"
})

# Memory persists across restarts
agent_memory.set("conversation_context", "discussing botwire faq")
time.sleep(1)  # Simulate process restart

# Data is still there
context = agent_memory.get("conversation_context")
print(context)  # "discussing botwire faq"

# List all keys in a namespace
all_keys = user_memory.list_keys()
print(all_keys)  # ["user-42"]

Each namespace has a 50MB limit and 1000 writes per day on the free tier. Reads are unlimited. There's no TTL by default — data persists until you delete it with m.delete(key) or clear the entire namespace with m.clear().

Framework Integration

BotWire provides adapters for popular AI frameworks. For LangChain chat history:

from botwire import BotWireChatHistory
from langchain.memory import ConversationBufferMemory

# Persistent chat history across sessions
history = BotWireChatHistory(session_id="user-42")
memory = ConversationBufferMemory(
    chat_memory=history,
    return_messages=True
)

# For CrewAI, get pre-built memory tools
from botwire.memory import memory_tools
tools = memory_tools("crew-agents")
# Returns: remember, recall, list_memory tools

When NOT to Use BotWire

• Vector search or embeddings: BotWire is key-value only, not a vector database
• High-throughput applications: 1000 writes/day limit on free tier
• Sub-millisecond latency requirements: HTTP API adds network overhead vs local storage

FAQ

Why not just use Redis or a database?

Redis requires running infrastructure. BotWire works immediately with zero setup. For prototyping and small-scale production, the simplicity wins. When you need more control, self-host the open-source version.

Is the free tier actually free?

Yes, permanently. 1000 writes/day per namespace, 50MB storage, unlimited reads. No credit card required. The business model is paid self-hosting support and enterprise features.

What about privacy and data ownership?

Your data stays in your namespace — isolated from other users. For full control, self-host using the MIT-licensed code at github.com/pmestre-Forge/signal-api. It's a single FastAPI + SQLite service.

BotWire Memory gives you persistent agent memory without infrastructure overhead. Start building immediately, then self-host when you need control.

pip install botwire

Try it at https://botwire.dev — no signup required.