> ## Documentation Index > Fetch the complete documentation index at: https://veniceai-mintlify-d2fddb8a.mintlify.site/llms.txt > Use this file to discover all available pages before exploring further. # Intégration LangChain > Intégrez les modèles Venice à LangChain pour des chaînes, des agents, l'utilisation d'outils et des pipelines RAG via le client ChatOpenAI compatible OpenAI et les SDK Python ou JS. Venice AI fonctionne en toute fluidité avec [LangChain](https://python.langchain.com/) 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 ```bash theme={null} pip install langchain langchain-openai openai ``` ## Modèles de chat Utilisez `ChatOpenAI` avec l'URL de base de Venice : ```python theme={null} 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 ```python theme={null} for chunk in llm.stream("Write a haiku about decentralization."): print(chunk.content, end="", flush=True) ``` ## Embeddings ```python theme={null} 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 pour Venice ) 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 ```python theme={null} 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 ```python theme={null} 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 : ```python theme={null} 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, ) # 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 ```python theme={null} 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 ```python theme={null} 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` : ```python theme={null} 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 : ```python theme={null} 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 | Parcourez tous les modèles Venice avec leur tarification et leurs capacités