Skip to main content
Aion provides helper functions to create LangChain chat models that are automatically configured for use within the Aion framework. These helpers handle authentication, endpoint selection, and runtime principal attribution transparently, so you can focus on your LangGraph logic.

​
Overview

from aion.langgraph.authoring import aion_chat_model, aion_chat_openai

# Generic approach (auto-detects the provider)
model = aion_chat_model("gpt-4o", temperature=0.7)

# Explicit LangChain ChatOpenAI
model = aion_chat_openai("gpt-4o", temperature=0.7)
Both helpers connect to the Aion control-plane model service and work in LangGraph nodes: 
from langgraph.graph import StateGraph

builder = StateGraph(State, context_schema=AionRuntimeContext)

async def analyze_node(state: dict):
    model = aion_chat_openai("gpt-4o", temperature=0)
    response = await model.ainvoke([HumanMessage(content="Analyze this...")])
    return {"analysis": response.content}

builder.add_node("analyze", analyze_node)

​
Functions

​
aion_chat_model(...)

aion_chat_model(
    model: str,
    **kwargs: Any,
) -> Any
Create a LangChain chat model configured for Aion using langchain.chat_models.init_chat_model. This is the generic approach that auto-detects the provider. For most use cases with Aion, you’ll use OpenAI models, so it behaves the same as aion_chat_openai. Parameters:
ParameterTypeDescription
modelstrModel ID from the Aion control plane model catalog (e.g., gpt-4o, gpt-4-turbo)
**kwargsAnyAdditional behavior options: temperature, max_tokens, timeout, max_retries, etc.
Note: Do not pass api_key, base_url, default_headers, http_async_client, or http_client. These are managed by Aion. Returns: A LangChain chat model (typically ChatOpenAI) ready to use. Raises:
  • ImportError — If LangChain is not installed
  • ValueError — If any reserved parameter is provided
Example: 
from aion.langgraph.authoring import aion_chat_model
from langchain_core.messages import HumanMessage

async def process_node(state: dict):
    # Create model with custom temperature
    model = aion_chat_model("gpt-4o", temperature=0.5)
    
    # Invoke synchronously or asynchronously
    response = await model.ainvoke([
        HumanMessage(content="What is the capital of France?")
    ])
    
    return {"answer": response.content}

​
aion_chat_openai(...)

aion_chat_openai(
    model: str,
    **kwargs: Any,
) -> ChatOpenAI
Create a langchain-openai ChatOpenAI model configured for Aion. Use this when you need explicit control or want to be specific about using OpenAI models. Parameters:
ParameterTypeDescription
modelstrOpenAI model ID (e.g., gpt-4o, gpt-4-turbo, gpt-3.5-turbo)
**kwargsAnyAdditional model options forwarded to ChatOpenAI.
Note: Do not pass api_key, base_url, default_headers, http_async_client, or http_client. These are managed by Aion. Returns: A ChatOpenAI instance backed by Aion’s model proxy. Raises:
  • ImportError — If langchain-openai is not installed
  • ValueError — If any reserved parameter is provided
Example: 
from aion.langgraph.authoring import aion_chat_openai
from langchain_core.messages import HumanMessage, SystemMessage

async def reasoning_node(state: dict):
    # Create a model tuned for reasoning
    model = aion_chat_openai(
        "gpt-4o",
        temperature=0.2,
        max_tokens=2000,
    )
    
    messages = [
        SystemMessage(content="You are a logical reasoning assistant."),
        HumanMessage(content="Prove that sqrt(2) is irrational."),
    ]
    
    response = await model.ainvoke(messages)
    return {"proof": response.content}

​
Usage in LangGraph Nodes

Models are typically created per-node invocation to ensure fresh authentication and principal context: 
from aion.langgraph.authoring import aion_chat_openai
from langchain_core.messages import HumanMessage
from langgraph.graph import StateGraph

class State(TypedDict):
    query: str
    response: str

builder = StateGraph(State)

async def answer_node(state: State) -> dict:
    model = aion_chat_openai("gpt-4o", temperature=0.7)
    response = await model.ainvoke([HumanMessage(content=state["query"])])
    return {"response": response.content}

builder.add_node("answer", answer_node)

​
Streaming

Both helpers return standard LangChain models that support streaming: 
from aion.langgraph.authoring import aion_chat_openai
from langchain_core.messages import HumanMessage

model = aion_chat_openai("gpt-4o")

async def stream_response():
    async for chunk in model.astream([
        HumanMessage(content="Tell me a story")
    ]):
        # Your code here: process each chunk as it arrives