Connect LangChain to Genten

Create a Genten identity for your Python agent so it can send events and chat.

Select LangChain from the four framework options.

Name and configure your agent

Give your agent a nickname, pick the model it uses, and choose an accent color. If you plan to chat with this agent from the dashboard (covered in Step 4), enter a Webhook URL now.

Fill in the nickname, model, optional webhook URL, and accent color. Then click Register My Agent.

Save your credentials

After clicking Register My Agent you'll see your credentials screen. All four values are shown here. Click Download Setup Info to save them as a file, or copy them individually.

Your credentials screen. Copy the API Key and Agent ID, or click Download Setup Info to save everything as a file. Your values will look different from this screenshot.

After registration you'll see four values. Copy the API Key and Agent ID and store them somewhere safe. You can also click Download Setup Info to save them as a file. If you ever need them again, go to My Agents → click your agent → the Connection Details section shows everything except the full API key. If you lose the API key, go to the agent detail page and click Rotate API Key to generate a new one.

The setup instructions screen has your credentials pre-filled in the code snippets. Click Finish Setup when done.

Install the packages your agent needs to talk to Genten.

Check if Python is installed

First, confirm Python is available on your machine. Open your terminal and run:

python3 --version

You should see something like Python 3.11.4. Any version 3.8 or higher is fine.

brew --version

If Homebrew is installed you'll see something like Homebrew 4.2.0. If you see command not found: brew, install Homebrew first. Go to brew.sh or run this command — it will take a few minutes:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Once Homebrew is installed, install Python:

brew install python3

This will take a few minutes. Once complete, re-run python3 --version to confirm it installed correctly.

Create a virtual environment

A virtual environment keeps your Python packages isolated to this project so they don't conflict with other Python projects on your machine. Without it, every package you install goes into your system Python — over time this causes version conflicts that are painful to debug. Always use a virtual environment.

Think of it like this: your system Python is a shared kitchen. A virtual environment is your own private kitchen where you control exactly what's in it.

First, navigate to your project folder. Run pwd inside your folder to get your exact path:

pwd

Your output will look something like this — copy it, you'll need it:

/Users/yourname/Desktop/your-project-langchain

Navigate to your folder (replace the path with your own pwd output):

cd /YOUR/PATH/HERE

Create the virtual environment:

python3 -m venv your-project-env

Activate it:

source your-project-env/bin/activate

Once activated, your terminal prompt will change to show (your-project-env) at the start. This confirms the virtual environment is active:

# Before activation:
username@computername your-project-langchain %

# After activation:
(your-project-env) username@computername your-project-langchain %

Install required packages

pip3 install requests flask

requests sends events and chat replies to Genten. flask receives chat messages from the dashboard (Step 4). If you only want one-way event monitoring, skip flask.

After running the install command you'll see output like this — Python is downloading and installing the packages:

Collecting requests
  Downloading requests-2.32.5-py3-none-any.whl (64 kB)
Collecting flask
  Downloading flask-3.1.3-py3-none-any.whl (103 kB)
...
Successfully installed blinker-1.9.0 certifi-2026.2.25 flask-3.1.3 requests-2.32.5 ...
WARNING: You are using pip version 21.2.4; however, version 26.0.1 is available.

The Collecting and Downloading lines are normal. Look for Successfully installed at the end — that's your confirmation. Your terminal should still show (your-project-env) prefacing the prompt when done.

Your agent tells Genten what it's doing by posting events to the ingest endpoint.

Create your test script

First, create a folder for your LangChain project files and navigate into it. You can put this anywhere on your machine — Desktop, your code folder, wherever you keep projects. Choose your own path:

mkdir /YOUR/PATH/HERE/your-project-langchain
cd /YOUR/PATH/HERE/your-project-langchain

Not sure what path to use? Navigate to where you want the folder in Finder, open a terminal there, and run pwd to get your exact path. For example:

/Users/yourname/Desktop

So your command would be:

mkdir /Users/yourname/Desktop/your-project-langchain
cd /Users/yourname/Desktop/your-project-langchain

Create the test file:

touch langchain_test.py

Open the folder in Finder so you can open the file in your code editor:

open .

Double-click langchain_test.py in Finder to open it in VS Code or your preferred editor. Then paste in the script below. Replace YOUR_API_KEY with the key from Step 1:

import requests

DASHBOARD_URL = "http://localhost:3001"
API_KEY = "YOUR_API_KEY"

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}

# Send a chain_start event
r1 = requests.post(
    f"{DASHBOARD_URL}/api/ingest/langchain",
    headers=headers,
    json={
        "event": "chain_start",
        "message": "Smoke test chain started"
    }
)
print(f"chain_start: {r1.status_code} {r1.text}")

# Send a chain_end event with cost
r2 = requests.post(
    f"{DASHBOARD_URL}/api/ingest/langchain",
    headers=headers,
    json={
        "event": "chain_end",
        "message": "Smoke test chain finished",
        "cost": 0.0012
    }
)
print(f"chain_end:   {r2.status_code} {r2.text}")

Run the script:

python3 langchain_test.py

You should see output like this. Mac users on Python 3.9 may see a NotOpenSSLWarning at the top — it's harmless, ignore it:

# Mac Python 3.9 users may see this warning -- safely ignore it:
# NotOpenSSLWarning: urllib3 v2 only supports OpenSSL 1.1.1+...

chain_start: 200 {"ok":true,"eventType":"start"}
chain_end:   200 {"ok":true,"eventType":"log"}

Both lines returning 200 means the connection is working. If you see anything other than 200, check the Troubleshooting section.

Both test events visible in Activity Feed with agent name, event type tag, message, and timestamp. If you see these, Step 3 is complete.

Available event types

Payload format

Let users chat with your LangChain agent directly from the Genten dashboard.

Two-way chat requires two things: a Flask server that receives messages from Genten, and a reply call that sends responses back.

How the chat flow works

1. User sends a message in Genten's Agent Chat
2. Genten POSTs the message to your agent's Webhook URL
3. Your Flask server receives the message and processes it
4. Your code POSTs the reply back to Genten's Reply Address
5. The reply appears in the chat

Agent detail page showing the Incoming Webhook field pre-filled. Click Edit to change it at any time.

Clicking Edit opens the webhook URL field for editing. Hit Save when done.

Create the chat server

Create a new file in the same folder as your langchain_test.py:

touch langchain_chat.py

Open the folder in Finder:

open .

Double-click langchain_chat.py to open it in your editor. Copy only the code block below — do not copy any of the surrounding text. Replace YOUR_API_KEY and YOUR_AGENT_ID with your values from the agent detail page.

from flask import Flask, request
import requests

app = Flask(__name__)

DASHBOARD_URL = "http://localhost:3001"
API_KEY = "YOUR_API_KEY"
AGENT_ID = "YOUR_AGENT_ID"

@app.route("/agent", methods=["POST"])
def handle_message():
    data = request.json
    user_message = data.get("text", "")
    print(f"Received: {user_message}")

    # Replace this with your actual LangChain logic
    reply_text = f"Echo: {user_message}"

    # Send the reply back to Genten
    requests.post(
        f"{DASHBOARD_URL}/api/chat/{AGENT_ID}/reply",
        headers={
            "Authorization": f"Bearer {API_KEY}",
            "Content-Type": "application/json"
        },
        json={"text": reply_text, "model": "langchain"}
    )
    print("Reply sent")
    return "", 204

if __name__ == "__main__":
    print("Agent listening on http://localhost:5001/agent")
    app.run(port=5001)

This is an echo server — it proves the pipeline works. Once verified, replace the reply_text line with your real LangChain logic:

# Example: swap the echo with a real LLM call
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o")
result = llm.invoke(user_message)
reply_text = result.content

Start your Flask server and send a message from the Genten dashboard.

python3 langchain_chat.py

You should see this output — the "development server" warning is normal and expected for local use:

Agent listening on http://localhost:5001/agent
 * Serving Flask app 'langchain_chat'
 * Debug mode: off
WARNING: This is a development server. Do not use it in a production
deployment. Use a production WSGI server instead.
 * Running on http://127.0.0.1:5001
Press CTRL+C to quit

Now go to Genten:

Your Flask terminal should print Received: [your message] and Reply sent. The reply should appear in Genten chat within a second or two.

The echo reply confirms the full pipeline is working: Genten → Flask → Genten. Replace the echo logic with your real LangChain code to get AI responses.