Langoedge End User Guide

Overview

Langoedge lets you design AI workflows as visual graphs, test them in chat, and deploy voice agents that handle phone calls. You can connect external apps via Pipedream, embed chat on your site, and run graphs through the API.

How Langoedge helps agent orchestration

Langoedge is built to orchestrate multiple AI steps, tools, and decision points into a single, predictable flow. Instead of a single monolithic prompt, you compose small, focused steps (nodes) and wire them together with explicit state, conditions, and tools.

Key orchestration capabilities:

• Stateful handoffs: Each node writes to a named field (for example, field3), and later nodes can read that field as an input. This makes handoffs explicit and debuggable.
• Deterministic routing: Conditional edges route the flow based on the value of a field. You can branch to tool-heavy steps vs. lightweight steps based on what your graph already learned.
• Tool gating: Tool Nodes and tool bindings let you scope which external tools are available at each step. This reduces unintended tool use and keeps behavior consistent.
• Separation of concerns: Keep retrieval, API calls, and reasoning in separate nodes. This makes it easier to update one part of the flow without affecting the rest.
• Multi-agent patterns: Voice graphs treat edges as callable transition tools. A voice agent can hand off to a different node (with different instructions) mid-call, which is useful for escalation or specialized handling.
• Hybrid voice + text orchestration: Voice graphs can invoke text graph configurations on transcripts, allowing specialized text agents to run in parallel while the call continues.
• Background execution: When enabled, long-running graphs can complete without blocking the chat UI, which is useful for heavy tools or data extraction.

Common orchestration patterns:

• Gate-and-route: Use an early node to classify the request, save the result to a field, then branch to specialized paths.
• Retrieve-then-reason: Run a Retriever Node to populate context, then pass that field into an LLM node.
• Validate-then-act: Use a custom function to validate inputs, then call APIs only when the validation field is true.
• Voice escalation: Start with a generalist voice node, then transition to a specialist node for billing, scheduling, or troubleshooting.

Visual guide

Orchestration overview

State and routing flow

Voice orchestration and text graph calls

Trigger deployment flow

Sign in and navigation

• All main screens require login.
• Sidebar: Graphs, Voice Graphs, Connect, Agents (opens in a new tab).
• User menu: Account (Langoedge secret), Subscription, Log out.

Build text graphs

Core concepts

• Graph = nodes + edges + shared state (fields).
• Nodes run operations and write results into a chosen state field.
• Edges define how the flow moves from one node to another.
• Tools are reusable capabilities (LLM, retriever, API, or non-LLM) that nodes can call.

State and field logic

Langoedge graphs pass data through named fields. Each run starts with a baseline state:

• field1 contains the user message for the run.
• file_contents contains the text extracted from any files you attached.

Default fields available in the UI:

• field1 through field15
• summaries
• file_contents

How fields work:

• Graph Nodes write their output to State to Update.
• Custom Function Nodes must return a dictionary that includes field or one of field1-field15.
  Example return value: {"field3": "priority: high"}.
• Output Node determines which node's output is returned as the final answer.
• Output State determines which field receives that final output.
• Tool Condition edges read State to Check and route the flow based on its value.

Mapping fields into a method:

• For method arguments labeled "State to get ... from", choose the field that should populate that argument.
• Use this to chain outputs between nodes (for example, map field2 into a summarization method).

Create or open a graph

1. Go to Graphs.
2. Click New to create a graph, or open Graph Templates and click a template to instantiate it.
3. Rename the graph from the header when the canvas is open.

Add nodes and connections

Use the plus button to open the node menu, drag nodes onto the canvas, and connect them.

Node types:

Graph Node deep dive

Graph Node is the default building block for most steps. It runs a selected operation (method), writes output to a state field, and optionally binds tools when the method supports them.

What you configure:

• Name: a stable identifier used in edges and output selection.
• Description: a short note explaining the step.
• Method: the operation to run (picked from the Operations list).
• State to update: which field receives the output (for example, field3 or summaries).
• Method arguments: values or state mappings that feed the operation.
• Tools bound with the LLM: available only for LLM methods, to scope tool usage.

Different usage patterns:

• Transform a field: read from field1, run a method, write to field2.
• Summarize or extract: run a method that produces a summary or structured output into summaries or a dedicated field.
• Routing signal: write a compact label (for example, "billing", "sales") into a field that a Tool Condition uses to branch.
• LLM with scoped tools: bind only the tools needed for this step so the model has focused capabilities.

When to use Graph Node vs other nodes:

• Use Graph Node for standard operations with clear inputs and outputs.
• Use Custom Function Node when you need inline custom logic that returns a field dictionary.
• Use Tool Node when you want to explicitly run one or more tools without a broader method.

Example flow with Graph Nodes:

1. Node A reads field1 and writes a classification label to field2.
2. A Tool Condition edge checks field2 and routes the flow.
3. Node B (sales path) writes a response to field3.
4. Node C (support path) writes a response to field4.
5. Output node is set to the final response node; Output state captures the final answer.

Additional Graph Node examples:

• Rewrite then polish
  • Node 1: Method = rewrite, input = field1, output = field2.
  • Node 2: Method = style polish, input = field2, output = field3.
  • Output node = Node 2, output state = field3.
• Extract then validate
  • Node 1: Method = extraction, input = field1, output = field4.
  • Node 2: Method = validation, inputs = field1 and field4, output = field5 (true/false or reason).
  • Tool Condition routes based on field5.
• Retrieve-augmented answer
  • Node 1: Retriever tool fills context in field6.
  • Node 2: LLM method uses field1 + field6, output = field7.
  • Output node = Node 2, output state = field7.
• API enrichment
  • Node 1: API tool fetches account data, output = field8.
  • Node 2: Summarize field8 into field9 for a user-facing response.
• Background long-run
  • Node 1: Heavy method runs with Execute in Background enabled.
  • Output node still points to the long-running node; the chat returns immediately while the run completes.

Configure node methods

Graph Nodes use a method selector to choose an operation. When a method is selected you can:

• Fill method arguments with constant values.
• Map method arguments from saved state (for example, field1, summaries, or file_contents).
• Bind tools when the method is an LLM operation (tools become callable inside that step).

Tips:

• If a node is connected, its name field becomes read-only. Disconnect it if you need to rename.
• For LLM methods, bind only the tools you want the model to use to avoid noisy tool calls.

Tools available (and where you use them)

Langoedge supports multiple tool types. The exact list you see in the UI is controlled by your backend configuration, so the dropdown is the source of truth.

Tool types:

• LLM tools (LLM Tool Node): define reusable prompts with a tool name + description.
• API tools (API Tool Node): call external HTTP endpoints with URL, method, headers, and path variables.
• Retriever tools (Retriever Node): fetch context from a vector store or index.
• Non-LLM tools (Tool Node): server-defined tools (for example, search, data access, or custom utilities) available in the Tools dropdown.

Where tools appear:

• Tool Node: choose one or more tools to run directly.
• LLM method binding: when a Graph Node uses an LLM method, you can bind specific tools so the model can call only those tools.
• Voice Graph nodes: optional Text Graph Tool lets a voice agent invoke a text graph as a callable tool.

How to confirm the available tools:

• Open any Tool Node and look at the Tools to be invoked dropdown.
• For LLM methods, open the Graph Node and check Tools bound with the LLM.

Tool usage tips:

• Keep tool names descriptive and stable; changes can break existing graphs.
• Scope tool bindings to the minimal set required for the step.
• Use a dedicated API Tool Node for external calls, then summarize or format the response in a following Graph Node.

Graph settings (toolbar)

• Trigger: pick a Pipedream trigger, fill its configuration, select an account if required, then deploy it.
• Graph protection level:
  • Public: anyone with access can run it.
  • Protected: only shared users can run it.
  • Private: only you can run it.
• Output node: which step provides the final answer.
• Output state: where the final output is stored.
• Execute in background: start the run without streaming the final answer in chat.
• Checkpoint TTL: how long to keep chat history for the thread.
• Model: choose the LLM for this graph.
• Test: open the chat drawer to run the graph end-to-end.
• Export: save the graph as a reusable template.
• Get embed code: copy a ready-to-use script snippet.

Test and debug

The chat panel supports:

• Streaming responses.
• A debug timeline showing the graph execution events.
• File attachments (paperclip). Uploaded files are available to the graph in the file_contents state.
• Exporting assistant replies to Word by clicking the download icon on a message.

Debug vs embedded behavior:

• In the Graph Builder, chat runs in debug mode and shows the execution timeline.
• In embedded chat, you see only the streamed assistant response.

Embed chat on your site

Use Get Embed Code from the toolbar. The embed script uses /chatbot.js and loads /embed/<graph-id>.

Example (replace with your app URL and graph id):

<script src="https://your-app.example.com/chatbot.js"></script>
<script>
  window.Chatbot.init({
    url: "https://your-app.example.com/embed/<graph-id>"
  });
</script>

Optional embed settings (from chatbot.js):

• width (default 350px)
• height (default 500px)
• buttonText (default Chat)

Note: the embedded chat route is authenticated in this app, so end users must be logged in unless your deployment removes that requirement.

Run graphs as agents

Open Agents to run a graph in a side-by-side view with chat. Pick the graph from the header dropdown, then chat with it to validate behavior.

Build voice graphs (voice agents)

Voice graph structure

Voice graphs are multi-agent voice workflows. Each node is a voice agent with its own instructions, and edges act as transition tools the agent can call to hand off to another node.

Node details:

• Name: used for identification and edge targeting.
• Instructions: the system-level behavior for that voice agent.
• Text Graph Tool (optional): attaches a text graph as a callable tool for this node.

Edge details:

• Transition tool name: the tool the voice agent calls to move to another node (must not contain spaces).
• Description: guidance the agent uses to decide when to transition.

Create a voice graph

1. Go to Voice Graphs and create a new graph.
2. Drag Voice Generic Nodes onto the canvas.
3. Edit each node to set:
   • Name
   • Instructions for the agent
   • Optional Text Graph Tool (links a text graph to this node as a callable tool)
4. Connect nodes with edges. Each edge needs a transition tool name and a short description.

How voice edges work:

• Each edge becomes a tool the voice agent can call to hand off to another node.
• The edge name is the tool name; the description guides when to use it.

Using text graphs with voice graphs

You can integrate text graphs in two different ways. Choose one or both based on your goal.

1. Live transcription analysis (automatic)

• Configure from the voice toolbar: Graph Configs to be invoked with the transcript.
• Each user utterance triggers the selected text graphs.
• Responses are injected into the voice agent context so it can react in real time.
• Best for: compliance checks, intent detection, call notes, sentiment tagging.

2. Text graph as a tool (on-demand)

• Configure per voice node: Text Graph Tool.
• The voice agent calls it only when needed based on the tool name/description.
• Best for: deep research, optional lookups, or expensive tasks you do not want to run every turn.

Tip: Avoid attaching the same text graph both as live transcription and as a tool unless you explicitly want it to run in both modes.

Example: live transcription summary

Goal: Summarize every user utterance and keep the summary in context.

1. Build a text graph named "Call summary".
   • Input from field1.
   • Output a short bullet summary.
2. Open the voice graph and select "Call summary" under Graph Configs to be invoked with the transcript.
3. During calls, each user utterance triggers the summary graph and the result is added to the agent context.

Example: text graph as a tool

Goal: Run a detailed pricing lookup only when the caller asks about pricing.

1. Build a text graph named "Pricing lookup".
   • Use a Retriever or API tool as needed.
   • Output the answer as a short response.
2. In the voice node, set Text Graph Tool:
   • Name: pricing_lookup
   • Description: "Use when the caller asks about pricing or plans."
3. The voice agent will call the tool only when it detects a pricing question.

Configure and test

In the voice toolbar:

• Choose the AI agent voice.
• Choose the phone number that should receive calls.
• Select Graph Configs to run automatically on the transcript (runs on each user utterance).
• Use Test voice agent to start a LiveKit call and speak to the agent.

Deploy

Click Deploy to publish the voice agent. When deployed, calls to the assigned phone number will route to the agent (assuming your LiveKit and telephony setup is configured).

Connect external apps

Use Connect to link Pipedream accounts. Supported apps include:

• Firecrawl
• Cloudinary
• Gmail
• LinkedIn
• Microsoft Outlook
• Microsoft Outlook Calendar
• Pinecone
• Qdrant
• Tavily

Connected accounts are required for triggers and some tools.

Trigger flow recap:

1. Connect the app account.
2. Pick a trigger and configure its properties.
3. Deploy the trigger to create a webhook that calls your graph.

Account and Langoedge secret

The Account page lets you create or rotate your Langoedge secret. The secret is shown once, so copy it and store it securely. Rotating the secret revokes the previous one.

API access for external apps

Use the Langoedge secret for server-to-server requests.

POST /graph-executions/invoke-from-external-app

• Header: x-langoedge-secret: <your secret>
• Form fields: graph_config_id, user_input, thread_id (optional)

The response is the final output from the graph. Use a consistent thread_id to keep conversation context.

If you need authenticated access to the full API (list graphs, templates, triggers, etc.), use the Auth0-based API base URL configured for your account.

Example (server-to-server):

curl -X POST "https://your-api.example.com/graph-executions/invoke-from-external-app" \
  -H "x-langoedge-secret: <your-secret>" \
  -F "graph_config_id=<graph-id>" \
  -F "user_input=Summarize this ticket" \
  -F "thread_id=customer-123"

Subscriptions

Open the user menu and select Subscription to start or manage your plan.

Troubleshooting

• If triggers will not deploy, connect the required account in Connect first.
• If the voice test panel shows a setup warning, your LiveKit/Auth0 configuration is missing. Contact your admin.
• If you see permission errors, check the graph protection level or graph ownership.