Set a value in the context. The value must be serializable. Most common Rust types are supported. # Examples ```rust use graph_flow::Context; use s

Get a value from the context. Returns `None` if the key doesn't exist or if deserialization fails. # Examples ```rust use graph_flow::Context; # #

Add a task to the graph

Synchronous version of get for use in edge conditions. This method should only be used when you're certain the data exists and when async is not avai

Add an edge between tasks

Add a user message to the chat history.

Add an assistant message to the chat history.

Check if the chat history is empty.

Get the number of messages in the chat history.

Get all chat history messages converted to rig::completion::Message format. This method is only available when the "rig" feature is enabled. # Examp

Acquire the chat history read lock, recovering from poisoning. A poisoned lock means a task panicked while holding it; the history itself is still va

Helper function to create internal server errors

Add a conditional edge with an explicit `else` branch. `yes` is taken when `condition(ctx)` returns `true`; otherwise `no` is chosen.

Acquire the chat history write lock, recovering from poisoning (see [`Context::history_read`]).

Add a message to the chat history, respecting max_messages limit.

Generate medical summary from extracted text using LLM

Get a clone of the current chat history. # Examples ```rust use graph_flow::Context; # #[tokio::main] # async fn main() { let context = Context::ne

Create an LLM agent using OpenRouter

----------------------------------------------------------------------------- A wrapper around `rig` so the example compiles only when OPENROUTER_API_

Main function: PDF → Images → LLM OCR → Text

Centralized function to call OpenRouter API with vision/text support

Connect with default pool settings (5 max connections) and run the schema migration. Use [`PostgresSessionStorage::with_pool`] for custom pool configu

Execute a single task without following Continue actions

Use LLM vision to extract text from images (OCR) - processes all images in one call

Find the next task based on edges and conditions

Get the last N messages from chat history. # Examples ```rust use graph_flow::Context; # #[tokio::main] # async fn main() { let context = Context::

Remove a value from the context. Returns the removed value if it existed. # Examples ```rust use graph_flow::Context; # #[tokio::main] # async fn

Add a system message to the chat history.

Clear all messages from the chat history.

Convert PDF to images using pdf2image

Create permissive CORS layer for development/testing

Very small heuristic fallback in case an LLM is not available.

Generate embedding for text using fastembed

Helper: obtain an embedding for the refined query using the `fastembed` crate.

NextAction::GoBack must still be matched until removed

Get all messages from chat history as SerializableMessage. # Examples ```rust use graph_flow::Context; # #[tokio::main] # async fn main() { let con

Get the last N messages converted to rig::completion::Message format. This method is only available when the "rig" feature is enabled. # Examples `

Very small wrapper around `rig` to obtain an agent that can answer our prompt.

Convert image to base64 for LLM vision API

Initialize structured JSON tracing based on environment variables

Get the last N messages. If N is greater than the total number of messages, all messages are returned. # Examples ```rust use graph_flow::ChatHisto

Get a reference to all messages.

Attempts to parse apartment insurance details from LLM response

Attempts to parse car insurance details from LLM response

Attempts to parse insurance type from LLM response

Execute **exactly one** task for the given `session_id` and persist the updated session. This method: 1. Loads the session from storage 2. Executes t

Set the maximum number of chained `ContinueAndExecute` steps allowed within a single `execute_session` call. Guards against accidental infinite loops

Synchronous version of set for use when async is not available. # Examples ```rust use graph_flow::Context; let context = Context::new(); context.s

Set the timeout duration for task execution

Synchronous, fallible version of [`Context::set`] (see [`Context::try_set`]).

Set a context prefix for storing aggregated child results. Aggregation keys will be written as `<prefix>.<child_id>.<field>`.

Create a new assistant message. # Examples ```rust use graph_flow::SerializableMessage; let msg = SerializableMessage::assistant("Hello! How can I