Vifu Python SDK

The Python SDK embeds the Vifu Runtime, Agent Gateway, and local Server. Python functions can become local Agent providers. Vifu("name") creates or reopens one real App in the personal Server and records its project binding in .vifu/app.json.

Create an environment and install Vifu:

python3 -m venv .venv
. .venv/bin/activate
python -m pip install vifu

The wheel contains the generated UniFFI binding, native Rust library, and the same complete Vifu binary distributed in Vifu releases. That binary includes the Server, Dashboard, TUI, Gateway, SQLite storage, and Runtime APIs. The Python API calls the Runtime in the application process. It reuses a running local Server or starts the bundled binary in Server-only mode.

The public API provides:

• Vifu for App identity, Agent registration, local Server connection, invocation, tracing, and remote calls.
• VifuRuntime for persistent Runtime state, Agent registration, invocation, snapshots, and pending traces.
• AgentTrace for activity, output deltas, and typed provider stages.
• VifuGateway for explicit remote enrollment and advanced Gateway control.
• VifuServer for advanced control of the bundled Vifu Server process.
• VifuServerConfig for typed local Server startup configuration from Python.
• AppProvider and Vifu.provider() for declaring reusable App-private Providers and binding them to Agent roles.
• LocalWhisper, LocalLlama, and OpenAICompatible for code-configured speech and language-model Providers.
• Vifu.run() for the same registered Agent App lifecycle locally and on a compatible managed host.

Call app.run() after registering Agents to serve Endpoint invocations until the local process stops. An App may instead pass a local entrypoint such as app.run(local_main). Vifu calls that entrypoint for direct local execution. A compatible managed host uses the registered Endpoints from the same script, does not enter the local interaction loop, and stops after its assigned invocation completes. Managed lifecycle details are not part of application input or output.

Framework integrations can be registered as normal Agent handlers. An integration may declare vifu_name, vifu_capability, vifu_metadata, vifu_instructions, and related defaults on the handler object. It may also implement vifu_bind(...) and vifu_run() when it owns one foreground runtime such as a voice session. Vifu.run() binds and starts that lifecycle, so the application entrypoint remains only Agent registration:

app.agent("voice", voice_agent)
app.agent("assistant", assistant_agent)
app.run()

Keep an Agent's implementation separate from the Provider it uses:

from vifu import LocalLlama, Vifu

app = Vifu("support-call")
reasoning = app.provider(
    "reasoning",
    LocalLlama(model="qwen2.5-3b-instruct-q4_k_m.gguf"),
)
app.agent(
    "reply-agent",
    reply_agent,
    implementation="strands-agents",
    providers={"reasoning": reasoning},
)

The App reports the Provider as an App-private resource. Vifu creates an Agent Profile only for reply-agent; it does not turn reasoning into another Agent.

Install the optional Strands integration, then select an OpenAI-compatible Provider directly in Python, including hosted and loopback model servers:

python -m pip install "vifu[strands]"

from vifu.integrations.strands import openai_compatible_model

model = openai_compatible_model(
    request,
    url="http://127.0.0.1:11434/v1/chat/completions",
    model="qwen2.5:7b",
)

The API key remains process configuration and is never included in Agent metadata. strands_model(...) remains available when an App intentionally uses a versioned Vifu Agent Profile.

Start with the Python tutorial. Runnable framework integrations are available for Google ADK and Foundry Local.