AI Agent Service Toolkit

A self-hosted foundation for serving LangGraph agents through FastAPI and Streamlit.

Stars
★ 4.6k
Last updated
1d ago
License
MIT
Primary language
Python

At a glance

How it runs
FrameworkSelf-hosted serviceWeb app
Works with
Universal · cross-platformOpenAI API
Cost
Free software; you pay for model usage
Setup effort
Medium · a few setup steps
You'll need
Pythonuv or pipAt least one LLM API key or provider configurationDocker and Docker Compose 2.23.0 or later for the documented container workflowShell / CLINetwork accessLocal filesystem
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
Maintenance
Commits in the last 30 dayslast commit 2026-11-16+1.0 ★/day over 7 days

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.

  1. A Python team evaluating LangGraph can start with an integrated agent, HTTP service, client, and chat UI instead of assembling each layer independently.
  2. A backend developer hosting several specialized agents can register them in one FastAPI service and address each agent through its own URL path.
  3. An application team that needs responsive output can consume token- or message-based streams and build a custom frontend on AgentClient.
  4. An engineer designing approval gates, persistent memory, or supervised agent workflows can adapt the examples using interrupt(), Command, Store, and langgraph-supervisor.
  5. A team prototyping internal knowledge assistance can start with the included basic ChromaDB RAG implementation and its documented setup.
  6. 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.py

In another shell, run:

source .venv/bin/activate
streamlit run src/streamlit_app.py

Alternatively, 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?

Pros
  • 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.
Limitations
  • 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?

FollowAgents source review · FARS-2.1
Some gaps
69/ 100 5-point scale 3.5 / 5
Trust 13/29
Reliability 9/14
Adaptability 15/18
Convention 15/18
Effectiveness 12/13
Verifiability 5/8
Why each dimension lost points
Trust13 / 29 · 2.2/5

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).

Reliability9 / 14 · 3.2/5

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).

Adaptability15 / 18 · 4.2/5

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).

Convention15 / 18 · 4.2/5

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).

Effectiveness12 / 13 · 4.6/5

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).

Verifiability5 / 8 · 3.1/5

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).

Risks and how to mitigate them
  • 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.
Evidence confidence: Low Reviewed Nov 07, 2026 Reviewed revision 8bb3cd36264c New commits since this review; the score may not cover them
See the full review method →
Maintain this project? Add the FARS badge to your README

The badge shows the current review score and verdict and links back to this page. It refreshes about once an hour after a re-review.

FARS

[![FARS review](https://followagents.com/badge/agent-service-toolkit.svg)](https://followagents.com/en/agents/agent-service-toolkit)
<a href="https://followagents.com/en/agents/agent-service-toolkit"><img src="https://followagents.com/badge/agent-service-toolkit.svg" alt="FARS review"></a>

FAQ

Is OpenAI the only supported model provider?
No. The repository says .env.example covers multiple model-provider keys and configurations, and it includes setup documentation for Ollama and VertexAI. At least one working LLM key or configuration is still required.
Is Docker mandatory?
No. The service and Streamlit app can be run directly after uv sync --frozen using python src/run_service.py and streamlit run src/streamlit_app.py. Docker Compose is an alternative recommended workflow.
Can I use the API without adopting Streamlit?
Yes. FastAPI independently exposes streaming and non-streaming endpoints, and AgentClient is intended for building other applications. Streamlit is the included reference chat frontend.
Does the default CI verify every optional backend?
No. Integrations requiring real PostgreSQL, MongoDB, AG-UI, or LangFuse infrastructure are checked manually through scripts/smoke_test.sh rather than the default CI run.
How are certificate or file-based credentials handled?
The repository provides privatecredentials/. Its contents other than .gitkeep are excluded from Git and Docker builds, and a dedicated file-based credentials document describes the suggested approach.
Is AI Agent Service Toolkit free?
The software is free, but AI Agent Service Toolkit calls an AI model, and you pay that model provider for usage (or run a local model).
Is AI Agent Service Toolkit open source?
Yes. The source code is on GitHub (JoshuaC215/agent-service-toolkit) under the MIT licence.
Is AI Agent Service Toolkit safe to use?
FollowAgents' FARS review (Nov 07, 2026) scored AI Agent Service Toolkit 13/29 on trust and safety. The review did not find these safety controls in the source: rollback or recovery path. Before giving it real accounts or data: Back up first, or work on a git branch or snapshot, so its changes can be undone. The repository has changed since that review.
Is AI Agent Service Toolkit still maintained?
Yes. The latest commit on GitHub is from 2026-11-16, within the last 30 days.
Who makes AI Agent Service Toolkit?
AI Agent Service Toolkit is published on GitHub by the account JoshuaC215. FollowAgents has not verified which person or company is behind that account.
What is AI Agent Service Toolkit's official website?
The project's GitHub repository lists https://agent-service-toolkit.streamlit.app as its website. That link is set by the repository owner; the source code itself is on GitHub (JoshuaC215/agent-service-toolkit).
Was this page helpful?
View on GitHub ↗ Install ↓

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related concepts