Swarmauri SDK

What does this agent do, and when should you use it?

Swarmauri SDK is a composable intelligence infrastructure library for Python, delivered as a monorepo that contains the swarmauri namespace package, the swarmauri_core contract layer, reusable swarmauri_base classes, first-party swarmauri_standard components, and community, plugin, standards, and experimental packages. Component families cover agents, chains, conversations, documents, embeddings, LLMs, parsers, prompts, tools, toolkits, vector stores, signing, key providers, transports, middleware, storage, and billing adapters, each independently installable. At runtime, importing swarmauri activates namespace discovery and populates InterfaceRegistry and PluginCitizenshipRegistry, while ComponentBase and Pydantic backed registration let SubclassUnion fields deserialize JSON payloads into concrete component types. Users install either the curated full bundle or only the focused packages their workflow needs, then import components directly from package modules. The repository ships a library and component ecosystem, not a running agent process or hosted service.

Importing swarmauri triggers namespace discovery that registers available component mappings in InterfaceRegistry and PluginCitizenshipRegistry. Developers then import concrete pieces from public swarmauri.* paths or directly from packages such as swarmauri_standard, instantiating classes like Document, AdditionTool, or Ed25519EnvelopeSigner. Component authors decorate classes with ComponentBase.register_model and ComponentBase.register_type so that Pydantic models using SubclassUnion[ComponentBase] can rebuild the right implementation from a JSON type field, as shown with a ConnectorBase/ApiConnector pair. Plugin packages advertise implementations through pyproject.toml entry points such as the swarmauri.vectorstores group, making them reachable after installation. The repo produces importable Python packages rather than a standalone executable or server.

1. Backend teams that want to mix several LLM providers, embedding models, and vector databases in one codebase without vendor lock-in.
2. Component authors building a pluggable tool, such as a Jupyter export or vector store writer, and distributing it as its own PyPI package.
3. Python applications assembling RAG pipelines where parsers, embeddings, and vector stores are installed separately.
4. System integrators needing Ed25519/JWS signing, key providers, and crypto components to harden data exchange.
5. Platform architects describing component configuration as Pydantic polymorphic schemas and validating it from JSON.

How do you install or deploy this agent?

Install the namespace package with uv:

uv add swarmauri

Or with pip:

pip install swarmauri

For a broader curated component bundle:

uv add "swarmauri[full]"
pip install "swarmauri[full]"

When you are only building components, install the foundational packages:

uv add swarmauri_core swarmauri_base
pip install swarmauri_core swarmauri_base

Install focused packages when you only need one component family:

uv add swarmauri_vectorstore_pinecone
uv add swarmauri_tool_jupyterexportlatex
uv add swarmauri_signing_ed25519

Python 3.10–3.14 is required. Provider packages (vector stores, embeddings, LLMs) additionally need their own credentials and SDK configuration, obtained from those vendors.

How do you use this agent?

Activate namespace discovery and inspect registered components:

import swarmauri

from swarmauri.interface_registry import InterfaceRegistry
from swarmauri.plugin_citizenship_registry import PluginCitizenshipRegistry

print(len(InterfaceRegistry.list_registered_namespaces()))
print(len(PluginCitizenshipRegistry.total_registry()))

Use the namespace for stable public imports once the implementation package is installed:

import swarmauri

from swarmauri.signings.Ed25519EnvelopeSigner import Ed25519EnvelopeSigner

signer = Ed25519EnvelopeSigner()
print(signer.type)

Import directly from packages when you want the narrowest dependency surface:

from swarmauri_standard.documents import Document
from swarmauri_standard.tools import AdditionTool

doc = Document(content="Direct package import")
tool = AdditionTool()

print(doc.type)
print(tool("2+2"))

Use swarmauri_base for dynamic component serialization via SubclassUnion:

from typing import Literal

from pydantic import BaseModel
from swarmauri_base.ComponentBase import ComponentBase
from swarmauri_base.DynamicBase import SubclassUnion


@ComponentBase.register_model()
class ConnectorBase(ComponentBase):
    type: Literal["ConnectorBase"] = "ConnectorBase"
    label: str


@ComponentBase.register_type(ConnectorBase, "ApiConnector")
class ApiConnector(ConnectorBase):
    type: Literal["ApiConnector"] = "ApiConnector"
    endpoint: str


class ConnectorSpec(BaseModel):
    connector: SubclassUnion[ConnectorBase]


spec = ConnectorSpec.model_validate_json(
    '{"connector":{"type":"ApiConnector","label":"primary","endpoint":"https://api.example.test"}}'
)

assert isinstance(spec.connector, ApiConnector)

Register an entry point so your own package is discoverable:

[project.entry-points.'swarmauri.vectorstores']
YourVectorStore = "swarmauri_vectorstore_yourplugin:YourVectorStore"

What are this agent's strengths and limitations?

How does this agent compare with similar options?

Key facts side by side with the most closely related agents.

How does FollowAgents rate this agent?

Recent releases

Latest entries from the project's GitHub Releases. Notes are quoted from upstream as written, not rewritten or tested by FollowAgents.

1. swarmauri_pop_cwt==0.11.0.dev5 Pre-release 2026-08-10
   Release notes excerpt

   Initial release.

   View on GitHub ↗

FAQ