AI工作流框架

3 Ways to Build

```python

3. Deploy — 1 command

v0.23.0 — Supabase Sessions + Builder RAG

Two user-facing features plus a post-ship bug-hunt sweep that pinned 8 code-generator fixes in the visual builder.

• SupabaseSessionStore — 4th SessionStore backend alongside JSON, SQLite, and Redis. Postgres-backed via Supabase PostgREST, with idempotent upserts, namespace isolation, and the same validation guards as RedisSessionStore. Optional dep: pip install selectools[supabase]. Demo: examples/96_supabase_session_store.py.

• Visual builder: first-class RAG + session nodes — drag Retriever (RAG) onto the canvas and pick any of 7 vector stores (memory, SQLite, Chroma, Pinecone, FAISS, Qdrant, pgvector), toggle Hybrid (BM25 + vector + RRF) and cross-encoder Rerank. Drag Session Store as a resource node and wire it into an agent via the new Session Store dropdown. Two new presets: Hybrid RAG and Multi-Tenant RAG. Python + YAML code generators emit real, runnable code.

from supabase import create_client
from selectools import SupabaseSessionStore, Agent, AgentConfig

store = SupabaseSessionStore(client=create_client(URL, KEY))
agent = Agent(
    tools=[...],
    config=AgentConfig(session_store=store, session_id="u-1", max_iterations=5),
)

See CHANGELOG.md for the full entry including the 8 builder code-gen fixes.

v0.20.1 — Visual Agent Builder + GitHub Pages

The first AI agent framework to ship a visual graph builder in a single pip install. No React. No build step. No CDN.

Try the builder in your browser → — no install required.

```bash pip install selectools selectools serve --builder

→ open http://localhost:8000/builder

```

• Drag START, END, and Agent nodes onto the canvas
• Click ports to connect agents with edges
• Add condition labels to edges (e.g. "approved") for conditional routing
• Edit provider, model, and system prompt in the properties panel
• Generated Python and YAML update live in the code panel
• Export or copy to clipboard with one click

v0.19.0 — Serve, Deploy & Complete Composition

```python

One command deploys your agent over HTTP with SSE streaming

Build a multi-agent graph in plain Python — no DSL, no compile step

graph = AgentGraph() graph.add_node("planner", planner_agent) graph.add_node("writer", writer_agent) graph.add_node("reviewer", reviewer_agent) graph.add_edge("planner", "writer") graph.add_edge("writer", "reviewer") graph.add_edge("reviewer", AgentGraph.END) graph.set_entry("planner") result = graph.run("Write a blog post about AI safety")

Install

pip install selectools                    # Core + basic RAG
pip install selectools[rag]               # + Chroma, Pinecone, FAISS, Qdrant, Voyage, Cohere, PyPDF, BeautifulSoup
pip install selectools[observe]           # + OpenTelemetry, Langfuse observers
pip install selectools[postgres]          # + psycopg2 (enables pgvector)
pip install selectools[cache]             # + Redis cache
pip install selectools[mcp]               # + MCP client/server
pip install "selectools[rag,observe,cache,mcp]"  # Everything

Add your provider's API key to a .env file in your project root:

``` OPENAI_API_KEY=sk-...

Reasoning strategies — guide the LLM's thought process

config = AgentConfig(reasoning_strategy="react") # Thought → Action → Observation config = AgentConfig(reasoning_strategy="cot") # Chain-of-Thought step-by-step config = AgentConfig(reasoning_strategy="plan_then_act") # Plan first, then execute

Quick Start

New to Selectools? Follow the 5-minute Quickstart tutorial — no API key needed.

Examples

Examples are numbered by difficulty. Start from 01 and work your way up.

Agent Configuration

config = AgentConfig(
    model="gpt-4o-mini",
    temperature=0.0,
    max_tokens=2000,
    max_iterations=6,
    max_retries=3,
    retry_backoff_seconds=2.0,
    request_timeout=60.0,
    tool_timeout_seconds=30.0,
    cost_warning_threshold=0.50,
    parallel_tool_execution=True,
    routing_only=False,
    stream=False,
    cache=None,                  # InMemoryCache or RedisCache
    tool_policy=None,            # ToolPolicy with allow/review/deny rules
    confirm_action=None,         # Human-in-the-loop approval callback
    approval_timeout=60.0,       # Seconds before auto-deny
    enable_analytics=True,
    verbose=False,
    observers=[LoggingObserver()],  # Lifecycle observer (replaces deprecated hooks)
    system_prompt="You are a helpful assistant...",
)

BUG-03: sync APIs now work in Jupyter / FastAPI handlers

agent.run("hello") # Just works inside async contexts ```

• 6 HIGH severity (shipping blockers): streaming dropped tool calls, typing.Literal crashed @tool(), asyncio.run() re-entry in 8 sync wrappers, HITL silently lost in parallel groups + subgraphs, ConversationMemory had no thread lock
• 9 MEDIUM severity: <think> tag stripping, RAG batch limits, MCP concurrent race, str→int/float/bool argument coercion, Union[str, int] support, multi-interrupt generators, GraphState fail-fast validation, session namespace isolation, summary growth cap
• 7 LOW-MED severity: cancelled-result extraction, AgentTrace lock, async observer exception logging, batch clone isolation, OTel/Langfuse observer locks, vector store search dedup, Optional[T] without default handling
• +57 new regression tests in tests/agent/test_regression.py, each with empirical fault-injection verification (test fails without fix, passes after)
• Thread safety end-to-end correct across ConversationMemory, AgentTrace, OTelObserver, LangfuseObserver, MCPClient, FallbackProvider, batch clone isolation

See CHANGELOG.md for the full per-bug breakdown with cross-references to every original Agno/PraisonAI issue.

v0.19.3 — Stability Markers Applied to All Public APIs

Every public class and function exported from selectools now carries a stability marker:

from selectools import Agent, AgentGraph, PlanAndExecuteAgent

print(Agent.__stability__)               # "stable"
print(AgentGraph.__stability__)          # "beta"
print(PlanAndExecuteAgent.__stability__) # "beta"

@stable — 60+ core symbols (Agent, AgentConfig, providers, memory, tools, evals, guardrails, sessions, knowledge, cache, cancellation)

@beta — 30+ newer symbols (AgentGraph, SupervisorAgent, Pipeline, @step, parallel, branch, all four patterns, compose)

or ANTHROPIC_API_KEY, GEMINI_API_KEY — whichever provider you use

```

Tool Calling Agent (No API Key)

from selectools import Agent, AgentConfig, tool
from selectools.providers.stubs import LocalProvider

@tool(description="Look up the price of a product")
def get_price(product: str) -> str:
    prices = {"laptop": "$999", "phone": "$699", "headphones": "$149"}
    return prices.get(product.lower(), f"No price found for {product}")

agent = Agent(
    tools=[get_price],
    provider=LocalProvider(),
    config=AgentConfig(max_iterations=3),
)

result = agent.ask("How much is a laptop?")
print(result.content)

Mark your own extensions with stability levels

@stable class MyProductionAgent: ...

@beta class MyExperimentalFeature: ...

@deprecated(since="0.19", replacement="MyProductionAgent") class MyOldAgent: ...

v0.18.0 — Composable Pipelines

```python from selectools import Pipeline, step, parallel, branch

@step def summarize(text: str) -> str: return agent.run(f"Summarize: {text}").content

@step def translate(text: str, lang: str = "es") -> str: return agent.run(f"Translate to {lang}: {text}").content

Load tools from a plugin directory

tools = ToolLoader.from_directory("./plugins", recursive=True) agent.add_tools(tools)

Hot-reload after editing a plugin

updated = ToolLoader.reload_file("./plugins/search.py") agent.replace_tool(updated[0])

Same question twice -> second call is instant (cache hit)

agent.ask("What is Python?") agent.reset() agent.ask("What is Python?")

print(cache.stats) # CacheStats(hits=1, misses=1, hit_rate=50.00%) ```

For distributed setups: from selectools.cache_redis import RedisCache