lovia

What is lovia

lovia is an Agent framework for Python that emphasizes a small core and optional extensions. The site describes it as lightweight, elegant, and provider-neutral, which means the framework is designed to stay minimal at the start and expand only when the application needs more than a basic Agent. In practice, lovia centers on a single Agent abstraction, typed Tools, and a run loop that makes model turns, tool calls, retries, and failures easier to follow.

The project documentation is organized as a learning path, so you can start with the first runnable example and move outward to more advanced agent features. It also includes English and Chinese documentation, plus architecture notes for people who want to understand the internals of the Agent framework rather than just use it.

Key features

lovia focuses on practical agent-building pieces that can be mixed in gradually. The documentation highlights these parts of the Agent framework:

• One explicit run path: model turns, tool calls, retries, and failures all follow a clear loop.
• Typed events and transcript tracking: the canonical Transcript shows what happened, which is useful for debugging agent runs.
• Provider-neutral design: the core stays independent from a specific model provider or gateway.
• Optional capabilities: streaming, persistence, context management, plugins, Workspace, and Web UI are available when needed.
• Built-in production controls: retries, budgets and limits, cancellation and steering, sessions and checkpoints, and guardrails are documented.
• Serving options: the app can be served through a Web UI, Web server, or HTTP API.
• Testing and evaluation tools: the docs include Testing, Evals, and Observability for checking agent behavior.
• Runnable examples: small scripts cover hello-world usage, Tool calls, streaming, structured output, and session history.

The framework also mentions extension areas such as Skills, MCP, Todo, and Memory, all using the same plugin seam instead of separate integration systems.

How to use it

lovia is meant to be approached step by step as an Agent framework.

1. Install it with pip install lovia.
2. Import Agent from lovia.
3. Create an Agent with a name, instructions, and a model placeholder or connected model.
4. Call run_sync() with a prompt to get a result.
5. Add typed Tools when the Agent needs actions beyond text generation.
6. Turn on streaming, sessions, checkpoints, plugins, or context management only after the first version works.
7. Use the example scripts in the repository to learn each feature in isolation.

The docs point to a quickstart, provider setup, built-in tools, structured output, and Web UI examples, so a typical workflow is to build a basic Agent first and then layer in more of the framework as the product grows.

Who it is for

lovia is a good fit for Python developers who want an Agent framework without a heavy default stack. It is especially relevant if you want to:

• build a first Agent with typed Tools instead of wiring many integrations by hand;
• keep model providers optional and switchable;
• add persistence, memory, or context management later;
• expose an agent through a Web UI, Web server, or HTTP API;
• test, evaluate, and observe agent behavior before shipping;
• study framework internals such as the RunLoop, Transcript invariants, and architecture layout.

It also makes sense for contributors who want a codebase with documented internals and a visible module map. The repository examples are intentionally small, so they can be copied, modified, and used as a feature-by-feature learning path for the Agent framework.

What to know before you use it

lovia is not a hosted chatbot or a no-code agent builder; it is an open-source Python library you run and wire into your own application. You should expect to configure your own model provider, because the site does not name a bundled default service or claim that setup is fully automatic.

A few limits and cautions are worth noting:

• The documentation site follows the current main branch, so it may move ahead of an installed release.
• The examples are written as a learning path, not as a finished application template.
• The framework includes production features like retries and guardrails, but it does not guarantee correct answers from a model.
• The architecture notes are useful if you need to understand compaction, persistence, or transcript behavior, but they are not a substitute for application-specific testing.
• For provider-specific behavior, rate limits, or account details, you should still check the official model or gateway documentation.

If you are evaluating an Agent framework for Python, lovia gives you a compact starting point and a clear path to add capabilities over time. It is strongest when you want an Agent framework that stays small at the core, then grows into a fuller agent stack only where your product needs it. lovia is best used as a Python Agent framework for building, serving, and testing agents with your own provider setup.