TTalkPro/beamai

BeamAI is an Erlang/OTP framework for building stateful, multi-turn conversational agents using the ReAct pattern. It provides a unified LLM client layer that abstracts interactions across multiple providers for chat, embeddings, and reranking, while managing connection pooling and automatic retries. The system features a pluggable architecture with onion-style filters, a tool registry, and persistent memory subsystems to support complex agent behaviors like human-in-the-loop control and sub-agent delegation.

The embedding subsystem now supports six providers: OpenAI, DashScope, Zhipu, SiliconFlow, Ollama, and a Mock provider for testing. A new \beamai\_embedding\_provider\_behaviour\ defines the unified interface, while \beamai\_embedding\_common\ handles shared request building and response parsing for OpenAI-compatible, Ollama-native, and DashScope-native formats. Each provider module implements this behaviour, allowing users to configure and use any of these backends for text vectorization.

_apps/beamai\llm/src/embedding · high confidence

The LLM adapter layer now supports multimodal inputs (images, audio, video, documents) via new \beamai\_llm\_content\ and \beamai\_llm\_media\ modules, allowing users to construct messages with media sources (URLs, base64, file IDs) that are automatically converted to provider-specific formats (e.g., OpenAI \image\_url\, Anthropic \image\). The \beamai\_llm\_message\_adapter\ handles these multimodal parts and supports features like prompt caching and prefix completion. Additionally, \beamai\_llm\_response\_parser\ introduces dedicated parsers for DeepSeek (including FIM and reasoning content), Anthropic (including web search and citations), and other providers, ensuring unified response structures across different LLM backends.

_apps/beamai\llm/src/adapters · high confidence

Users can now perform document re-ranking (rerank) as a second stage in RAG pipelines using six new providers: Jina, Cohere, Voyage, DashScope, SiliconFlow, and a local Mock provider for testing. This change introduces a unified provider behavior and common helper modules in the \beamai\_llm\ application to handle provider-specific request construction, response parsing, and error handling, enabling cross-encoder based relevance scoring for retrieved documents.

_apps/beamai\llm/src/rerank · high confidence

BeamAI Core is introduced as the foundational module for the BeamAI framework, providing a ChatClient architecture for stateless LLM interactions, a pluggable tool registry and executor, and a decoupled conversation memory subsystem. The library includes an onion-style filter system for wrapping tool loops and LLM calls, an ETS-based default memory store, and a Gun-based HTTP client. It also defines standard behaviors for LLM chat, memory storage, and tool modules, along with utilities for JSON-RPC, SSE, and UUID generation.

_apps/beamai\core · high confidence

Introduces the \beamai\_agent\ application, a stateful, multi-turn conversational agent built on the ReAct pattern. It features an autonomous tool loop that manages memory via \beamai\_memory\_provider\ and triggers a comprehensive callback system (including LLM events, tool calls, and results) without injecting filters into the underlying \beamai\_chat\_client\. Key capabilities include parallel tool execution, streaming output, and interrupt/resume functionality with support for cross-node persistence via DETS. The agent also supports sub-agent delegation, allowing it to spawn and manage child agent sessions as tools.

_apps/beamai\agent · high confidence

The \beamai\_llm\ application is introduced as the central LLM client layer, providing a unified interface for chat, embedding, and reranking operations across multiple providers. It supports OpenAI, Anthropic, DeepSeek, Ollama, Zhipu AI, Alibaba Cloud DashScope, xAI, Moonshot/Kimi, OpenRouter, and SiliconFlow for chat; OpenAI, DashScope, Zhipu, SiliconFlow, and Ollama for embeddings; and SiliconFlow, DashScope, Jina AI, Cohere, and Voyage AI for reranking. The layer features a provider-based architecture where providers declare API specifics (endpoints, headers, parsers) while the \chat\_model\ handles retries and request normalization. It includes adapters for multimodal content (images, audio, video, PDF) and tool calling, ensuring consistent \beamai\_chat\_response\ structures for both synchronous and streaming calls.

_apps/beamai\llm · high confidence

The parser module now provides a unified interface for parsing LLM outputs into JSON, XML, CSV, or raw text. The JSON parser includes robust error handling, automatically extracting JSON from markdown code blocks, repairing common syntax errors (like trailing commas), and stripping markdown formatting. It also supports optional JSON Schema validation. If parsing fails, the system can automatically retry with configurable backoff strategies (linear, exponential, or fibonacci) and custom callbacks, improving reliability when dealing with imperfect LLM responses.

_apps/beamai\llm/src/parser · high confidence

The \beamai\_agent\ application is introduced as a new, stateless ReAct agent framework built on OTP supervision, replacing the previous \gen\_server\-based implementation. This change provides a robust execution model featuring a replaceable tool loop (allowing strategies like plan-execute or tree search), comprehensive human-in-the-loop (HITL) support with interrupt/resume capabilities, and persistent pause snapshots via \beamai\_agent\_pause\ for cross-process recovery. It also introduces sub-agent delegation tools (\beamai\_agent\_delegate\) for synchronous and asynchronous task offloading, a rich callback system for observability, and configurable limits such as \max\_tool\_calls\ to cap total tool invocations per run.

_apps/beamai\agent/src · high confidence

The \beamai\_llm\ application now provides a unified interface for chat, embedding, and reranking operations across multiple providers (OpenAI, Anthropic, DashScope, Zhipu, Ollama, DeepSeek, etc.). It introduces a standardized error classification system (\beamai\_llm\_error\) that normalizes HTTP and API errors, enabling automatic, configurable retry logic with exponential backoff for transient failures (429, 5xx, timeouts) while respecting server-suggested \Retry-After\ headers. The chat module supports both synchronous and streaming responses, with streaming explicitly excluded from automatic retries to prevent duplicate token delivery. Embedding and reranking modules also leverage this shared retry mechanism, with embedding supporting automatic batching and reranking enforcing document count limits.

_apps/beamai\llm/src · high confidence

This change establishes the foundational components for LLM interaction within the core module. It introduces \beamai\_chat\_client\ as the primary entry point for single LLM calls and tool invocations, managing tool registration and executing an onion-style filter chain. A new \beamai\_filter\ module defines the middleware architecture with granular hooks (around\_chat, around\_tool, around\_turn, around\_step) and a dedicated \beamai\_filter\_chain\ to compose them. To support conversation history, two memory backends are added: an in-memory ETS implementation (\beamai\_chat\_memory\_ets\) and a persistent DETS implementation (\beamai\_chat\_memory\_dets\), along with a \beamai\_memory\_filter\ for automatic history injection. The system also includes a robust \beamai\_context\ for managing execution state and variables, a \beamai\_json\_schema\ validator for structured output enforcement, and a suite of built-in filters (\beamai\_filters\) for logging, safety guardrails, timeouts, and approval workflows.

_apps/beamai\core/src/core · high confidence

The \beamai\_core\ application now includes new utility modules in \src/utils\ to support agent communication and data handling. \beamai\_id\ provides a new, cryptographically secure ID generation system that produces time-ordered, parseable identifiers with prefixes, replacing previous ad-hoc methods. \beamai\_jsonrpc\ adds standard JSON-RPC 2.0 encoding and decoding capabilities, including support for batch requests and error construction, serving as a shared foundation for A2A and MCP protocols. \beamai\_sse\ introduces Server-Sent Events parsing and encoding for stream-based communication. Additionally, \beamai\_utils\ has been refactored to migrate JSON encoding from the \jsx\ library to the OTP \json\ module, ensuring backward-compatible handling of proplists while simplifying the dependency footprint.

_apps/beamai\core/src/utils · high confidence

The examples/src directory now includes a comprehensive set of Erlang examples demonstrating the BeamAI library's core capabilities. Users can explore single-turn and multi-turn chat interactions via ChatClient, stream responses, and configure various LLM providers (Anthropic, OpenAI-compatible, Zhipu) through the example\_llm\_config module. The suite also showcases the new tool architecture with refactored tool definitions and a ReAct agent loop, as well as the onion-style filter mechanism for intercepting and modifying chat and tool calls. Additionally, prompt template rendering and JSON output parsing are demonstrated to help users integrate structured data extraction into their workflows.

examples/src · high confidence

This change introduces a new set of LLM provider modules (Anthropic, DashScope, DeepSeek, Moonshot, Ollama, OpenAI, OpenRouter, and Mock) that delegate HTTP request execution to a new centralized \beamai\_llm\_http\_provider\ module. This new layer standardizes how requests are sent, handling timeout defaults, connection pool routing, and rate-limit metadata extraction via a shared \beamai\_llm\_provider\_common\ module. Users benefit from consistent streaming accumulation and finalization across providers, support for provider-specific features like Anthropic's prompt caching and DeepSeek's FIM completion, and unified handling of tool calls and usage statistics.

_apps/beamai\llm/src/providers · high confidence

The LLM core layer introduces three new modules to standardize how chat interactions are handled. \beamai\_chat\_request\ provides a structured way to define model inputs, separating persistent provider configuration from per-call options like temperature, tools, and streaming settings. \beamai\_chat\_response\ replaces the previous response type, offering a unified interface for accessing content, tool calls, usage stats, and provider-specific raw data, while explicitly supporting \content\_blocks\ to preserve native provider structures (such as Anthropic's thinking blocks) for cache-friendly history replay. \beamai\_message\ adds builder functions for creating standardized system, user, and assistant messages, along with a \from\_response/1\ utility to convert LLM responses into neutral message formats that retain necessary content blocks.

_apps/beamai\core/src/llm · high confidence

Added a new standalone example project located in the examples directory, including a Makefile for compiling, running a shell, and cleaning, along with a rebar.config and rebar.lock file. The example depends on the poolboy library (version 1.5.2) and is configured to use the main project's build output via ERL\_LIBS, specifically launching the beamai\_core application in the shell.

examples · high confidence

The project has been restructured into a core library (this repository) and an extension project (beamai\_extra). The core now focuses on three responsibilities: beamai\_core (ChatClient, Filters, Tools), beamai\_agent (SimpleAgent), and beamai\_llm (Unified LLM client). The Process Framework and storage/snapshot engine (formerly beamai\_process/beamai\_memory) have been removed from this repository. The framework now requires Erlang/OTP 27+ and uses the gun HTTP client. Documentation has been updated to reflect these changes, including new English README and architecture docs.

(repo-wide) · high confidence

This change introduces the \beamai\_core\ application, providing a unified facade (\beamai\) for building ChatClients, registering tools, and invoking LLM chat completions. The core now supports an onion-style filter mechanism (via \beamai\_filter\) that wraps requests and responses around chat, step, tool, and turn operations. A significant behavioral update is the HTTP client layer: the legacy single-pool \http\_pool\ configuration is deprecated in favor of \http\_pools\, which allows distinct configuration for short, stream, and longpoll traffic classes using the Gun backend. The supervision tree (\beamai\_core\_sup\) now manages these three named HTTP pool instances, validating pool names at startup to prevent silent failures.

_apps/beamai\core/src · high confidence

The HTTP layer now uses the Gun library as the default backend, replacing previous implementations. This change introduces a connection pool manager that separates traffic into short, streaming, and long-poll pools to prevent resource contention. Users can now access response status codes and headers via the new \request\_meta\ API, and streaming requests support a \forward\_headers\ option to pass initial response headers to handlers. The pool configuration defaults to HTTP/1.1 to ensure compatibility across both HTTP and HTTPS schemes.

_apps/beamai\core/src/http · high confidence

This change introduces five new behaviour modules in \beamai\_core/src/behaviours\ that define standard interfaces for the system's core components. \beamai\_chat\_behaviour\ specifies the contract for chat completion and streaming requests across providers (e.g., OpenAI, DashScope). \beamai\_chat\_memory\ and \beamai\_memory\_provider\ separate low-level session storage (get/add/clear) from high-level agent memory strategies (history loading, appending, and pre-send transformation like windowing). \beamai\_http\_behaviour\ abstracts the HTTP client, adding support for streaming requests and returning response metadata (status codes and headers). Finally, \beamai\_tool\_behaviour\ defines the interface for tool modules, allowing them to expose tool definitions and optional filters. These behaviours decouple the core logic from specific implementations, enabling pluggable backends and standardized extension points.

_apps/beamai\core/src/behaviours · high confidence

Added test coverage for core chat client, streaming, memory, and filter chain components; Comprehensive test coverage for beamai\_agent core behaviors; Expanded test coverage for LLM retry, embedding, and provider-specific features.

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 54 → 55 (+1.2)
• Rubric changed (rubric-2026.09.12 → rubric-2026.09.18) — scores are not directly comparable.

• Code Health 95 → 95 (+0.0)
• Architecture 94 → 93 (-1.4)
• Maturity 64 → 64 (+0.0)
• Readiness 26 → 29 (+3.1)
• Security 100 → 98 (-2.5)

• Coverage not measured — no coverage collector is wired up
• Hotspot: apps/beamai_core/src/core/beamai_tool_error.erl (apps/beamai_core/src/core/beamai_tool_error.erl)
• Hotspot: apps/beamai_core/src/core/beamai_tool_index_keyword.erl (apps/beamai_core/src/core/beamai_tool_index_keyword.erl)
• Hotspot: apps/beamai_core/src/http/beamai_http_gun.erl (apps/beamai_core/src/http/beamai_http_gun.erl)
• Hotspot: apps/beamai_llm/src/adapters/beamai_llm_message_adapter.erl (apps/beamai_llm/src/adapters/beamai_llm_message_adapter.erl)
• Hotspot: apps/beamai_llm/src/beamai_llm_error.erl (apps/beamai_llm/src/beamai_llm_error.erl)

• Dependency not covered by the lockfile: beamai_core
• High CVE: [GHSA redacted] (rebar.lock)
• High CVE: [GHSA redacted] (rebar.lock)
• Off the main sequence: beamai_core
• Outdated: esqlite
• Outdated: gun
• Outdated: uuid_erl
• Unbounded dependency requirement: beamai_core

• 1 commits — 1 feature/other, 0 fixes

• apps/beamai_llm — 1 commit

• change: 为anthropic的provider添加全新的cache策略

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

TTalkPro/beamai was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.