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.

v0.28.0 — Hardening Sweep: Shell Safety, Session Namespaces & Typed Public API

A full audit-driven tech-debt sweep — mostly additive and bugfix, with one called-out behavior change.

• execute_shell is now a real boundary, not a best-effort filter — it parses with shlex and runs with shell=False, so pipes, chaining (;, &&), redirection, subshells, globbing, and backgrounding can never be interpreted (closes the previously-bypassable \n and bare-& holes). Behavior change: commands relying on shell features now fail fast instead of running through /bin/sh.
• SSRF guard extended to the headless-browser tools and the serve webhook — browser_scrape_page/browser_screenshot and the eval-alert webhook now reject loopback/private/link-local targets; SSRF logic is consolidated into one shared validator.
• Session namespaces fixed across all backends — SessionStore.branch() gained an optional namespace parameter, and list() now returns a round-trippable storage key consistently (JSON/Redis/Mongo/DynamoDB previously returned a bare id that couldn't be reloaded for namespaced sessions).
• Embedding providers accept timeout + max_retries (OpenAI/Voyage/Cohere, default 60s/2) so a hung or rate-limited call can't block ingestion.
• Typed public API — AgentResult.trace/.usage and the ten AgentConfig nested-group fields are now their concrete types instead of Any (full autocomplete + type-checking); tightening surfaced and fixed two real bugs the Any had masked.
• Packaging — added the missing [cache] extra (redis), pytz to [toolbox], and jsonschema to [evals].

See CHANGELOG.md for the full entry (7,796 tests, 115 examples, 115 models).

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 carries a stability marker. As of 1.0, @stable symbols carry a compatibility promise — no removal or breaking signature change without a deprecation cycle of at least two minors:

from selectools import Agent, AgentGraph, AgentScheduler

print(Agent.__stability__)          # "stable"
print(AgentGraph.__stability__)     # "stable"  (promoted for 1.0)
print(AgentScheduler.__stability__) # "beta"    (still iterating)

@stable — the frozen core: Agent, AgentConfig, providers, memory, tools and the mature toolbox, sessions, guardrails, orchestration graphs, the pattern agents, the policy layer, and the core types.

@beta — subsystems still evolving in 1.x: RAG/embeddings, MCP, A2A, the evaluator catalog, unified memory, the scheduler, and the newest backends. Run python scripts/stability_audit.py for the live marker map.

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