AI Agent Service Toolkit
A self-hosted foundation for serving LangGraph agents through FastAPI and Streamlit.
- Source repo
- JoshuaC215/agent-service-toolkit
- Stars
- ★ 4.6k
- Last updated
- 1d ago
- License
- MIT
- Primary language
- Python
- FA score
- 69/100 · Some gaps
At a glance
- How it runs
- Works with
- Universal · cross-platformOpenAI API
- Cost
- Free software; you pay for model usage
- Setup effort
- Medium · a few setup steps
- You'll need
- Typical use
- A Python team evaluating LangGraph can start with an integrated agent, HTTP service, client, and chat UI instead of assembling each layer independently.
- Not a fit if
- Users who want a ready-made assistant, not to build and deploy their own agents
- Anyone wanting a lightweight single-process tool with no database or Docker stack
- Website
- agent-service-toolkit.streamlit.app ↗ set on GitHub
- Maintenance
- Commits in the last 30 dayslast commit 2026-11-16+1.0 ★/day over 7 days
- Source review
- 69/100 · Some gaps 1 safety controls not found
What does this agent do, and when should you use it?
This repository is a complete Python template for building and operating LangGraph agent services rather than a single-purpose assistant. It combines several agent implementations, a FastAPI service, a reusable AgentClient, and a Streamlit chat application with text and voice interaction. The service supports streaming and non-streaming calls, selects agents by URL path, and exposes every agent through the AG-UI protocol for compatible frontends. Included examples cover human intervention, long-term memory, supervised multi-agent flows, moderation, basic ChromaDB RAG, conversation history, and LangSmith feedback. It can run in a local Python environment or as a Docker Compose stack containing PostgreSQL, the agent service, and the Streamlit application.
The service loads registered implementations from src/agents/ and serves them through the FastAPI application in src/service/service.py. Consumers call /<agent_name>/invoke for ordinary responses or /<agent_name>/stream for token- or message-oriented streaming; /info describes available agents and models, while /threads lists a user's prior conversations by agent. src/client/client.AgentClient wraps synchronous, asynchronous, streaming, and non-streaming requests, and src/streamlit_app.py uses that client to produce a chat UI with voice input and output, previous-chat navigation, and star feedback. The agent examples use LangGraph interrupt(), Command, Store, and langgraph-supervisor for human-in-the-loop execution, flow control, long-term memory, and supervised agent arrangements. Optional paths include a basic ChromaDB RAG agent, Safeguard moderation requiring a Groq API key, AG-UI endpoints, and PostgreSQL or MongoDB checkpoint backends.
- A Python team evaluating LangGraph can start with an integrated agent, HTTP service, client, and chat UI instead of assembling each layer independently.
- A backend developer hosting several specialized agents can register them in one FastAPI service and address each agent through its own URL path.
- An application team that needs responsive output can consume token- or message-based streams and build a custom frontend on AgentClient.
- An engineer designing approval gates, persistent memory, or supervised agent workflows can adapt the examples using interrupt(), Command, Store, and langgraph-supervisor.
- A team prototyping internal knowledge assistance can start with the included basic ChromaDB RAG implementation and its documented setup.
- A frontend team using CopilotKit or another AG-UI-compatible client can connect to the AG-UI endpoint exposed for each agent.
Key setup facts
Pulled from the install and usage notes below. The project README has the current values.
- Install / run
curl -LsSf https://astral.sh/uv/0.11.32/install.sh | sh
- Environment variables
OPENAI_API_KEY- Config files
.env.env.example- Install notes cover
- Docker
How do you install or deploy this agent?
Prepare a Python environment and configure at least one LLM API key or provider connection. A documented quick start is:
git clone https://github.com/JoshuaC215/agent-service-toolkit.git
cd agent-service-toolkit
echo 'OPENAI_API_KEY=your_openai_api_key' >> .env
curl -LsSf https://astral.sh/uv/0.11.32/install.sh | sh
uv sync --frozen
source .venv/bin/activate
python src/run_service.pyIn another shell, run:
source .venv/bin/activate
streamlit run src/streamlit_app.pyAlternatively, create .env from .env.example and run docker compose watch. The documented container workflow requires Docker and Docker Compose 2.23.0 or later.
How do you use this agent?
After startup, open the Streamlit interface at the URL it reports, normally http://localhost:8501. The FastAPI service is available at http://0.0.0.0:8080, with API documentation at http://0.0.0.0:8080/redoc. A minimal client call is:
from client import AgentClient
client = AgentClient()
response = client.invoke("Tell me a brief joke?")
response.pretty_print()To add an agent, place its implementation in src/agents/, register it in the agents dictionary in src/agents/agents.py, and call /<your_agent_name>/invoke or /<your_agent_name>/stream. Adjust src/streamlit_app.py if the UI must reflect the new capabilities. Run pytest for the test suite; changes involving PostgreSQL, MongoDB, AG-UI, or LangFuse can be checked selectively with ./scripts/smoke_test.sh postgres, mongo, agui, or langfuse.
What are this agent's strengths and limitations?
- It covers the full path from LangGraph definitions through FastAPI serving and a reusable client to a working Streamlit interface, with both streaming and non-streaming access.
- It demonstrates LangGraph 1.0 mechanisms including interrupt(), Command, Store, and langgraph-supervisor for approvals, control flow, memory, and supervised agent systems.
- Every registered agent is also exposed through AG-UI, enabling compatible frontends such as CopilotKit, while AgentClient supports independently built applications.
- It documents both local Python and Docker Compose workflows and includes unit, integration, and opt-in end-to-end smoke tests.
- Operation requires at least one LLM API key or provider configuration, and Safeguard moderation adds a separate Groq API-key dependency.
- The Docker workflow runs PostgreSQL, FastAPI, and Streamlit services, making it heavier to operate than a single-process agent script.
- PostgreSQL, MongoDB, AG-UI, and LangFuse smoke tests are opt-in and are not exercised by the default CI run.
- The test suite currently has to be run through the local, non-Docker development setup.
- The repository is maintained by one person on a roughly biweekly triage cycle, so non-urgent responses may take one or two weeks.
How does this agent compare with similar options?
Key facts side by side with the most closely related agents.
| Agent | Source review | Form / cost | Stars | Updated | Language | Full support on |
|---|---|---|---|---|---|---|
| AI Agent Service Toolkit This agent | 69 · Some gaps | FrameworkFree + model costs | ★ 4.6k | 1d ago | Python | OpenAI API |
| Agents Towards Production | 44 · Major gaps | Library / SDKFree + model costs | ★ 22k | 1d ago | Jupyter Notebook | — |
| OpenAgent | 46 · Major gaps | Self-hosted serviceFree + model costs | ★ 755 | 1d ago | Python | OpenAI API |
| Agent Craft | 52 · Major gaps | CLIFree + model costs | ★ 536 | 21d ago | Python | OpenAI API |
How does FollowAgents rate this agent?
Why each dimension lost points
The README, pyproject.toml, and CLAUDE.md describe LLM/API credential configuration, ignored private credential files, and human review boundaries for maintenance automation, providing some data-flow and sensitive-credential guidance (2). The sample does not show endpoint authentication or fine-grained permissions for agent tools, so least privilege and external-effect controls have limited evidence (1 each). The maintainer-response skill defaults to drafting rather than posting, offering a limited confirmation boundary (1). The deployment workflow pushes an image and deploys it to Azure, but no rollback path is shown (0). The README and maintenance skills identify upstream frameworks and integrations such as LangSmith, providing partial attribution (2).
The README, test samples, and configuration support a broadly consistent architecture and agent-loading behavior, but the tests shown use mocks and do not establish runtime correctness (2). pyproject.toml constrains many dependencies and the dependency-refresh skill describes a lockfile workflow and 14-day resolution cooldown; the sample does not establish that every external service remains available (2). Tests show clear errors for missing or unloaded agents, and the smoke-test skill documents failure conditions, though full service error handling is not included (2).
The README serves developers building or running LangGraph services and covers local models, cloud providers, RAG, Docker, clients, and custom agents (3). It describes API, multiple-agent, optional-RAG, and credential requirements, but gives limited detail on the actions and risk boundaries of agent tools (2). The sample skills have explicit triggers and applicability conditions, and the README separates specialized deployment and integration instructions (2). Python 3.12–3.14, local and Docker setups, multiple model providers, and optional components are documented (3).
The README is organized into architecture, quickstart, setup, customization, Docker, development, and contribution sections (3). It gives concrete installation steps, environment-variable references, Docker requirements, and local run instructions (3). Package, service, and directory names are broadly consistent, but the sample provides no stable compatibility policy beyond version 0.1.0 (2). It includes walkthroughs, client code, video, focused documentation, and guidance for tests and optional smoke tests (3). It discloses that some infrastructure tests are outside default CI and that the LangFuse smoke test is resource-intensive, but does not comprehensively describe security or failure limitations (2). The LICENSE explicitly grants MIT terms (3). pyproject.toml gives a version, but the supplied materials contain no changelog or release history (1). The README identifies solo maintenance, roughly biweekly triage, and the location of maintenance automation documentation (3).
The FastAPI service, client, Streamlit UI, streaming support, agent examples, and deployment configuration form a usable toolkit with clear outputs (3). Its value is combining agents, service, client, and UI into a customizable template with several integration paths (3). Numerous base dependencies and external API keys, plus Docker and optional infrastructure, add setup cost; local instructions and targeted smoke-test guidance mitigate some of that cost (2).
README claims about setup, architecture, and features are partially supported by pyproject.toml, workflows, and test samples, but many implementation files are absent from the supplied evidence (2). The README, configuration, and tests provide limited cross-checks for agent loading, dependencies, and deployment; the sample is incomplete and cannot confirm every advertised feature (2). The documentation distinguishes defaults, optional dependencies, and smoke-test scope, but claims such as “robust” are not established by the supplied files (2).
- Not found in source: rollback or recovery pathBack up first, or work on a git branch or snapshot, so its changes can be undone.
- The sample does not show service authentication, agent-tool permissions, or complete data-flow implementation. The deployment workflow pushes and deploys images, with no rollback guidance shown.
- Some README feature claims lack corresponding implementation files in the supplied material; this static review does not imply execution or independent verification.
FAQ
Is OpenAI the only supported model provider?
Is Docker mandatory?
Can I use the API without adopting Streamlit?
Does the default CI verify every optional backend?
How are certificate or file-based credentials handled?
Is AI Agent Service Toolkit free?
Is AI Agent Service Toolkit open source?
Is AI Agent Service Toolkit safe to use?
Is AI Agent Service Toolkit still maintained?
Who makes AI Agent Service Toolkit?
What is AI Agent Service Toolkit's official website?
Thanks — we use this to improve the page.