LangChain

Intégrez Venice à LangChain pour chaînes, agents, outils et pipelines RAG via le client ChatOpenAI compatible OpenAI et les SDK Python ou JS.

Venice AI fonctionne en toute fluidité avec LangChain grâce à la compatibilité totale avec le SDK OpenAI. Construisez des chaînes, agents et pipelines RAG avec l’infrastructure orientée confidentialité de Venice.

​

Installation

pip install langchain langchain-openai openai

​

Modèles de chat

Utilisez ChatOpenAI avec l’URL de base de Venice :

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="venice-uncensored-1-2",
    api_key="your-venice-api-key",
    base_url="https://api.venice.ai/api/v1",
    temperature=0.7,
)

response = llm.invoke("Explain privacy-preserving AI in 2 sentences.")
print(response.content)

​

Streaming

for chunk in llm.stream("Write a haiku about decentralization."):
    print(chunk.content, end="", flush=True)

​

Embeddings

Venice n’embarque que du texte. OpenAIEmbeddings de LangChain utilise par défaut check_embedding_ctx_length=True, ce qui tokenise avec tiktoken et peut envoyer des tableaux d’entiers correspondant aux tokens. Venice les rejette avec HTTP 400, il faut donc définir check_embedding_ctx_length=False.

from langchain_openai import OpenAIEmbeddings

embeddings = OpenAIEmbeddings(
    model="text-embedding-bge-m3",
    api_key="your-venice-api-key",
    base_url="https://api.venice.ai/api/v1",
    check_embedding_ctx_length=False,  # Requis : envoyer du texte, pas des ID de tokens
)

vectors = embeddings.embed_documents([
    "Venice AI provides private inference.",
    "No data is retained after processing.",
])
print(f"Embedding dimension: {len(vectors[0])}")

​

Chaînes

​

Chaîne simple avec un modèle de prompt

from langchain_core.prompts import ChatPromptTemplate

prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a {role}. Answer concisely."),
    ("user", "{question}"),
])

chain = prompt | llm
response = chain.invoke({"role": "privacy expert", "question": "Why does zero data retention matter?"})
print(response.content)

​

Chaîne séquentielle

from langchain_core.output_parsers import StrOutputParser

# Chaîne 1 : Générer un résumé du sujet
summarizer = ChatPromptTemplate.from_messages([
    ("user", "Summarize this topic in 3 bullet points: {topic}")
]) | llm | StrOutputParser()

# Chaîne 2 : Générer des questions à partir du résumé
questioner = ChatPromptTemplate.from_messages([
    ("user", "Based on this summary, generate 3 thought-provoking questions:\n{summary}")
]) | llm | StrOutputParser()

# Composer
summary = summarizer.invoke({"topic": "decentralized AI inference"})
questions = questioner.invoke({"summary": summary})
print(questions)

​

Pipeline RAG

Construisez un pipeline de génération augmentée par récupération (RAG) avec Venice :

from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_community.vectorstores import FAISS
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_core.output_parsers import StrOutputParser

# Initialiser les modèles Venice
llm = ChatOpenAI(
    model="zai-org-glm-5-1",
    api_key="your-venice-api-key",
    base_url="https://api.venice.ai/api/v1",
)

embeddings = OpenAIEmbeddings(
    model="text-embedding-bge-m3",
    api_key="your-venice-api-key",
    base_url="https://api.venice.ai/api/v1",
    check_embedding_ctx_length=False,  # Requis : envoyer du texte, pas des ID de tokens
)

# Charger et découper les documents
documents = [
    "Venice AI provides private, uncensored AI inference with zero data retention.",
    "The Venice API is OpenAI-compatible, supporting chat completions, images, audio, video, and embeddings.",
    "Venice supports function calling, structured outputs, web search, and reasoning models.",
    "Privacy levels include Private (zero retention) and Anonymized (third-party processed).",
]

# Créer le vector store
vectorstore = FAISS.from_texts(documents, embeddings)
retriever = vectorstore.as_retriever(search_kwargs={"k": 2})

# Prompt RAG
rag_prompt = ChatPromptTemplate.from_messages([
    ("system", "Answer the question based only on the following context:\n\n{context}"),
    ("user", "{question}"),
])

# Chaîne RAG
def format_docs(docs):
    return "\n\n".join(doc.page_content for doc in docs)

rag_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | rag_prompt
    | llm
    | StrOutputParser()
)

answer = rag_chain.invoke("What privacy levels does Venice offer?")
print(answer)

​

Function calling avec des agents

from langchain_core.tools import tool
from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain_core.prompts import ChatPromptTemplate

# Utiliser un modèle compatible function calling
llm = ChatOpenAI(
    model="zai-org-glm-5-1",
    api_key="your-venice-api-key",
    base_url="https://api.venice.ai/api/v1",
)

@tool
def get_venice_model_price(model_id: str) -> str:
    """Get the pricing for a Venice AI model."""
    prices = {
        "venice-uncensored-1-2": "Input: $0.20/1M, Output: $0.90/1M",
        "zai-org-glm-5-1": "Input: $1.75/1M, Output: $5.50/1M",
        "qwen3-5-9b": "Input: $0.10/1M, Output: $0.15/1M",
    }
    return prices.get(model_id, f"Model {model_id} not found in price list.")

prompt = ChatPromptTemplate.from_messages([
    ("system", "You help users find the right Venice AI model. Use tools when needed."),
    ("placeholder", "{chat_history}"),
    ("user", "{input}"),
    ("placeholder", "{agent_scratchpad}"),
])

agent = create_tool_calling_agent(llm, [get_venice_model_price], prompt)
executor = AgentExecutor(agent=agent, tools=[get_venice_model_price], verbose=True)

result = executor.invoke({"input": "What's the cheapest Venice text model?", "chat_history": []})
print(result["output"])

​

Sortie structurée

from pydantic import BaseModel, Field

class MovieReview(BaseModel):
    title: str = Field(description="Movie title")
    rating: float = Field(description="Rating out of 10")
    summary: str = Field(description="One-sentence summary")

structured_llm = llm.with_structured_output(MovieReview)
review = structured_llm.invoke("Review the movie Inception")
print(f"{review.title}: {review.rating}/10 — {review.summary}")

​

Intégration de la recherche web

Utilisez la recherche web intégrée de Venice via venice_parameters :

from langchain_openai import ChatOpenAI

llm_with_search = ChatOpenAI(
    model="venice-uncensored",
    api_key="your-venice-api-key",
    base_url="https://api.venice.ai/api/v1",
    extra_body={
        "venice_parameters": {
            "enable_web_search": "auto"
        }
    }
)

response = llm_with_search.invoke("What are the latest developments in AI this week?")
print(response.content)

Ou passez-le requête par requête :

response = llm.invoke(
    "What are the latest developments in AI this week?",
    extra_body={"venice_parameters": {"enable_web_search": "auto"}}
)

​

Modèles recommandés pour LangChain

Cas d’usage	Modèle	Pourquoi
Chaînes générales	venice-uncensored	Rapide, économique, non censuré
Raisonnement complexe	zai-org-glm-5-1	Meilleur modèle phare privé
Function calling	zai-org-glm-5-1	Utilisation fiable des outils
Vision + texte	qwen3-vl-235b-a22b	Compréhension visuelle avancée
Génération de code	qwen3-coder-480b-a35b-instruct	Optimisé pour le code
Embeddings (RAG)	text-embedding-bge-m3	Embeddings privés
Budget / fort volume	qwen3-5-9b	0,10 $/1 M en entrée

Voir tous les modèles

Parcourez tous les modèles Venice avec leur tarification et leurs capacités