Intégration de LangChain avec Alibaba Bailian

LangChain est actuellement le framework de développement d'applications de grands modèles de langage (LLM) le plus populaire. Il aide les développeurs à créer rapidement des applications de prompt, de modèle, de chaîne d'outils et d'agent grâce à des interfaces de composants unifiées.

Alibaba Cloud Bailian (DashScope) est la plateforme de services LLM d'Alibaba Cloud, proposant la série de modèles de chat Tongyi Qianwen (qwen), des modèles d'embedding de texte et des modèles reranker.

Cet article explique comment intégrer les modèles Bailian avec LangChain, en couvrant trois catégories : les modèles de chat, les modèles d'embedding de texte et les modèles reranker. Il fournit également des exemples complets en Python, JavaScript et Java.

Prérequis

Nous devons activer le service de modèle Alibaba Cloud Bailian et obtenir une API-KEY.

Tout d'abord, nous pouvons utiliser le compte principal Alibaba Cloud pour visiter la plateforme de service de modèles Bailian :https://bailian.console.aliyun.com/Cliquez ensuite sur « Login » dans le coin supérieur droit. Après vous être connecté, cliquez sur l'icône d'engrenage ⚙️ dans le coin supérieur droit, sélectionnez « API Key », puis copiez la clé API. Si vous n'en avez pas, vous pouvez également créer une clé API :

Avant de commencer, commençons par comprendre deux concepts clés : les « classes d'intégration de modèles » de LangChain et les « deux modes d'intégration » de Bailian.

Classes d'intégration de modèles

LangChain encapsule les modèles de différents fournisseurs dans des « classes d'intégration » unifiées.

Le code d'application s'appuie sur une interface unifiée. Lorsque vous changez de fournisseur, il vous suffit de modifier la classe d'intégration et les paramètres ; la logique métier doit rarement être modifiée.

En prenant les modèles de chat comme exemple, côté Python, il existe deux classes d'intégration, ChatOpenAI et ChatTongyi, correspondant respectivement au mode compatible OpenAI de Bailian et au mode natif DashScope.

Deux modes d'intégration

Bailian fournit deux ensembles de protocoles d'intégration ; différents protocoles correspondent à différentes classes d'intégration LangChain.

Mode compatible OpenAILe protocole API est cohérent avec OpenAI. Tout framework qui prend en charge le protocole OpenAI peut se connecter directement, ce qui entraîne le coût d'intégration le plus faible.

Mode natif DashScopeIl utilise le protocole DashScope propre à Bailian et peut appeler tous les modèles de génération de texte de Bailian, y compris les modèles personnalisés déployés.

L'architecture d'intégration globale est présentée dans le diagramme suivant :

LangChain 集成阿里云百炼架构图

L'interface dite « compatible OpenAI » signifie que le protocole d'API HTTP du fournisseur est cohérent avec OpenAI.

Tant que le protocole est compatible, tout code ou outil écrit pour OpenAI peut être réutilisé directement, seul le point de terminaison de l'API devant être modifié.

Configurer les variables d'environnement

Tous les langages et méthodes d'intégration utilisent uniformément la variable d'environnementDASHSCOPE_API_KEYpour stocker la clé API.

Export dans le terminal sous Linux / macOS :

export DASHSCOPE_API_KEY="sk-你的百炼APIKey"

Configuration de Windows (CMD) :

set DASHSCOPE_API_KEY=sk-你的百炼APIKey

Il est recommandé d'écrire la commande d'export dans le fichier de configuration du shell (par exemple, ~/.bashrc, ~/.zshrc) pour éviter de devoir la redéfinir à chaque ouverture d'un terminal.

Configurer via un fichier .env (recommandé)

Une approche encore plus recommandée consiste à écrire la clé API dans un fichier .env à la racine du projet et à utiliser python-dotenv pour la charger automatiquement dans les variables d'environnement.

Séparer la clé API du code, combiné à .gitignore, évite les commits accidentels et facilite à chacun la maintenance de sa propre configuration lors d'une collaboration.

Créez un fichier .env à la racine du projet :

# 文件路径：项目根目录/.env
DASHSCOPE_API_KEY=sk-你的百炼APIKey

Par exemple, dans notre projet de testexample-langchain-testcréez le.envfichier, et ajoutez la configuration :

Installez python-dotenv :

pip install python-dotenv

Chargez le fichier .env au début de votre code Python :

Exemple

from dotenv import load_dotenv

load_dotenv()  # Lire le fichier .env dans le répertoire racine du projet et l'injecter en tant que variables d'environnement

Après le chargement, os.getenv("DASHSCOPE_API_KEY") dans votre code peut lire la clé, ce qui a le même effet que de l'exporter manuellement.

Cette méthode de chargement a déjà été illustrée dans les exemples de la section « Chat Model ».

Le fichier .env est sensible. Veuillez l'ajouter à .gitignore (écrivez une ligne ".env") pour empêcher que la clé API soit commitée dans le dépôt.

Veuillez remplacer la clé API dans les exemples par une vraie clé, et ne la partagez jamais avec d'autres.

Comparaison des deux modes d'intégration

Regardez d'abord un tableau comparatif, puis choisissez le mode d'intégration selon vos besoins.

Élément de comparaisonMode compatible OpenAIMode natif DashScope
Principe d'intégrationRéutilise la classe d'intégration du protocole OpenAIUtilise le SDK natif DashScope
Modèles pris en chargeSeulement certains modèlesTous les modèles de génération de texte et les modèles déployés
Classe d'intégration PythonChatOpenAIChatTongyi
Classe d'intégration JavaScriptChatOpenAIChatAlibabaTongyi
Classe d'intégration JavaOpenAiChatModelQwenChatModel
Scénarios applicablesLe code OpenAI existant doit basculer rapidementBesoin de toutes les capacités du modèle ou utiliser des modèles déployés

Les deux modes utilisent le même domaine, dashscope.aliyuncs.com. La différence réside dans le chemin : le chemin du mode compatible OpenAI est /compatible-mode/v1, tandis que le chemin du mode natif DashScope est intégré au SDK.

Modèle de chat

Les modèles de chat sont le type de modèle le plus couramment utilisé, utilisé pour des tâches telles que le dialogue multi-tours, les questions-réponses et la génération de contenu.

Ci-dessous, nous présentons les méthodes d'intégration par langage. Le modèle d'exemple utilise uniformément qwen-plus, qui peut être remplacé selon les besoins.

Python : Mode compatible OpenAI

Utilisez la classe d'intégration ChatOpenAI du package langchain_openai pour appeler Bailian en tant que service OpenAI.

Installez d'abord les dépendances :

pip install langchain_openai

Exemple de code :

Exemple

from langchain_openai import ChatOpenAI
from dotenv import load_dotenv  # Lire la configuration depuis le fichier .env
import os

load_dotenv()  # Charger les variables d'environnement telles que la clé API depuis le fichier .env dans le répertoire racine du projet

# Créer une instance de modèle de chat, se connectant à Bailian via le protocole compatible OpenAI
chatLLM = ChatOpenAI(
    api_key=os.getenv("DASHSCOPE_API_KEY"),  # Lire la clé API Bailian à partir de la variable d'environnement (obligatoire)
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",  # Point de terminaison d'API compatible avec OpenAI de Bailian (obligatoire)
    model="qwen-plus",  # Nom du modèle (obligatoire), ici qwen-plus utilisé comme exemple
    # Autres paramètres facultatifs : temperature, max_tokens, etc.
)

# Construire une liste de messages de conversation à plusieurs tours
messages = [
    {"role": "system", "content": "Vous êtes un assistant utile."},  # Message système, définir le rôle de l'assistant
    {"role": "user", "content": "Qui êtes-vous ?"},  # Message utilisateur, le contenu de la question
]

# Effectuer l'appel et renvoyer un objet de réponse structuré
response = chatLLM.invoke(messages)
print(response.model_dump_json())

Résultat de sortie (certains champs omis) :

{
  "content": "我是通义千问，由阿里云开发的大语言模型，可以回答你的问题、协助创作、提供建议等。",
  "usage": { "prompt_tokens": 12, "completion_tokens": 28, "total_tokens": 40 }
}

Après un appel réussi, un objet AIMessage est renvoyé. model_dump_json() peut le sérialiser en JSON pour faciliter la consultation de la réponse complète.

Python : mode natif DashScope

Utilisez la classe d'intégration ChatTongyi du package langchain-community, qui utilise le protocole natif DashScope et prend en charge la sortie en streaming.

ChatTongyi provient du package langchain-community, et ce package ainsi que dashscope ne sont plus maintenus.

Pour les nouveaux projets, il est recommandé de privilégier l'intégration ChatOpenAI compatible OpenAI. N'envisagez cette approche que lorsque vous avez besoin des capacités natives de DashScope (comme les modèles déployés).

Installez d'abord les dépendances :

pip install langchain-community dashscope

Exemple de code :

Exemple

from langchain_community.chat_models.tongyi import ChatTongyi
from langchain_core.messages import HumanMessage
from dotenv import load_dotenv  # Lire la configuration depuis le fichier .env
import os

load_dotenv()  # Charger les variables d'environnement telles que les clés API depuis le fichier .env à la racine du projet

# Créer le modèle de chat Qwen en utilisant le protocole natif DashScope
chatLLM = ChatTongyi(
    model="qwen-plus",  # Nom du modèle (obligatoire)
    dashscope_api_key=os.getenv("DASHSCOPE_API_KEY"),  # Lire la clé API depuis une variable d'environnement (obligatoire)
    streaming=True,  # Activer la sortie en streaming
)

# Diffuser l'appel, en recevant et imprimant le contenu de la réponse morceau par morceau
res = chatLLM.stream([HumanMessage(content="hi")], streaming=True)
for r in res:
    print("chat resp:", r.content)

Résultat de sortie :

chat resp: 你好
chat resp: ！我是通义千问，有什么可以帮您的吗？

La sortie en streaming permet au modèle de renvoyer le contenu morceau par morceau pendant la génération, ce qui la rend adaptée aux interfaces de chat qui ont besoin d'un effet de machine à écrire.

Modèle d'embedding de texte

Les modèles d'embedding convertissent le texte en vecteurs sémantiques, formant la base d'applications telles que RAG (Retrieval-Augmented Generation) et la recherche sémantique.

Sélection du modèle

Bailian propose plusieurs versions de modèles d'embedding. Vous pouvez comparer leurs performances à l'aide des métriques d'évaluation MTEB et CMTEB ; plus la valeur est élevée, mieux c'est.

ModèleMTEBMTEB (tâche de récupération)CMTEBCMTEB (tâche de récupération)
text-embedding-v158.3045.4759.8456.59
text-embedding-v260.1349.4962.1762.78
text-embedding-v3 (1024 dimensions)63.3955.4168.9273.23
text-embedding-v4 (1024 dimensions)68.3659.3070.1473.98

Lorsque text-embedding-v3 et text-embedding-v4 sont appelés via LangChain, vous ne pouvez pas spécifier la dimension du vecteur ; ils produisent des vecteurs de 1024 dimensions par défaut.

Les versions supérieures offrent de meilleures performances, donc privilégiez v4.

Exemple Python

L'API d'embedding de Bailian est compatible avec la spécification de l'API OpenAI. Utilisez simplement la classe d'intégration OpenAIEmbeddings du package langchain-openai et pointez base_url vers le point de terminaison compatible de Bailian.

Pas besoin d'installer les paquets langchain-community et dashscope qui ne sont plus maintenus.

Installez d'abord les dépendances :

pip install langchain-openai

OpenAIEmbeddings nécessite trois paramètres clés : model (nom du modèle d'embedding), api_key (clé API Bailian) et base_url (point de terminaison compatible OpenAI de Bailian).

base_url est défini sur https://dashscope.aliyuncs.com/compatible-mode/v1, qui est identique au point de terminaison compatible pour les modèles de chat.

Exemple de code :

Exemple

from langchain_openai import OpenAIEmbeddings
from dotenv import load_dotenv  # Lire la configuration depuis le fichier .env
import os

load_dotenv()  # Charger les variables d'environnement telles que les clés API depuis le fichier .env à la racine du projet

# Créer une instance de modèle d'embedding pour se connecter à Bailian via le protocole compatible OpenAI
# chunk_size=10 : l'API Embedding de Bailian accepte au maximum 10 textes par requête.
# OpenAIEmbeddings regroupe 1000 éléments à la fois par défaut ; si la base de connaissances est légèrement volumineuse, elle dépassera la limite et signalera une erreur.
embeddings = OpenAIEmbeddings(
    model="text-embedding-v4",  # Nom du modèle d'embedding (obligatoire), en utilisant v4 comme exemple ici
    api_key=os.getenv("DASHSCOPE_API_KEY"),  # Lire la clé API Bailian à partir d'une variable d'environnement (obligatoire)
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",  # Point de terminaison compatible OpenAI de Bailian (obligatoire)
    check_embedding_ctx_length=False,
    chunk_size=10,
)

# Vectoriser un seul texte de requête
text = "Ceci est un document de test."
query_result = embeddings.embed_query(text)
print("Longueur du vecteur de texte :", len(query_result), sep='')

# Vectoriser plusieurs documents par lots
doc_results = embeddings.embed_documents(
    [
        "Salut !",
        "Oh, bonjour !",
        "Comment tu t'appelles ?",
        "Mes amis m'appellent World",
        "Hello World!"
    ])
print("Nombre de vecteurs de texte :", len(doc_results), ", longueur du vecteur de texte :", len(doc_results[0]), sep='')

Résultat de sortie :

文本向量长度：1024
文本向量数量：5 ，文本向量长度：1024

embed_query est utilisé pour vectoriser une requête utilisateur, et embed_documents est utilisé pour vectoriser par lots des documents candidats. La similarité ne peut être calculée que lorsque les deux vecteurs de sortie ont la même dimension.

Modèle de reranking

Les modèles de reranking réévaluent et reclassent les résultats de récupération, améliorant considérablement la qualité des réponses des applications RAG.

Paramètres du modèle

Bailian fournit les modèles de reranking suivants ; choisissez en fonction de la langue, du coût et du scénario :

ModèleNombre maximal de documentsEntrée maximale par élémentLangues prises en chargePrix unitaire (par millier de tokens)Scénarios applicables
qwen3-vl-rerank1008,000 Token33 langues principales, notamment le chinois, l'anglais, le japonais, le coréen, etc.Image 0.0018 yuan / texte 0.0007 yuanRegroupement d'images, recherche intermodale, recherche d'images
qwen3-rerank5004,000 Token100+ langues, dont le chinois, l'anglais, l'espagnol, le français, le japonais, le coréen, etc.0.0005 yuanRecherche sémantique de texte, applications RAG
gte-rerank-v2—30,000 TokenPlus de 50 langues, y compris le chinois, l'anglais, le japonais, le coréen, le thaï, etc.0.0008 yuanReclassement de textes longs

Exemple Python

Utilisez la classe d'intégration DashScopeRerank du paquet langchain-community.

Cet exemple utilise DashScopeRerank du paquet langchain-community.

langchain-community et dashscope ne sont plus maintenus. Pour les nouveaux projets, veuillez prêter attention aux méthodes d'intégration alternatives fournies officiellement par Bailian.

Installez d'abord les dépendances :

pip install langchain-community dashscope

Exemple de code :

Exemple

from langchain_community.document_compressors.dashscope_rerank import DashScopeRerank
from dotenv import load_dotenv  # Lire la configuration depuis le fichier .env

load_dotenv()  # Charger les variables d'environnement telles que les clés API depuis le fichier .env à la racine du projet

# Simuler une liste de textes candidats renvoyés par la récupération
sequence = ["exemple est un site web d'apprentissage du chinois qui fournit des tutoriels de programmation", "text2", "text3"]

# Créer une instance de modèle reranker
reranker = DashScopeRerank(
    model="gte-rerank-v2",  # Nom du modèle reranker (requis)
)

# Réordonner les textes candidats en fonction de la requête, en renvoyant les top_n avec les scores les plus élevés
print(reranker.rerank(documents=sequence, query="Qu'est-ce que Python", top_n=2))

La méthode rerank recalcule les scores et reclasse les documents candidats en fonction de la requête, et top_n spécifie le nombre de résultats à renvoyer. Elle est couramment utilisée dans l'étape de classement fin après la récupération RAG.

Intégration de JavaScript et Java

JavaScript : mode compatible OpenAI

Sur Node.js, utilisez la classe d'intégration ChatOpenAI du paquet @langchain/openai.

Installez d'abord les dépendances :

npm install @langchain/openai @langchain/core

Exemple de code :

Exemple

import { ChatOpenAI } from "@langchain/openai";

// Créer une instance de modèle de chat pour se connecter à Bailian via le protocole compatible OpenAI
const llm = new ChatOpenAI({
  model: "qwen-plus",  // Nom du modèle (obligatoire), en utilisant qwen-plus comme exemple ici
  apiKey: process.env.DASHSCOPE_API_KEY,  // Lire la clé API Bailian depuis une variable d'environnement (obligatoire)
  configuration: {
    baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1",  // Point de terminaison de l'API compatible OpenAI de Bailian (obligatoire)
  },
});

// Effectuer un appel de chat, en retournant l'objet de message IA
const aiMsg = await llm.invoke([
  { role: "system", content: "Vous êtes un assistant utile qui traduit l'anglais vers le français. Traduisez la phrase de l'utilisateur." },  // Message système
  { role: "user", content: "J'aime la programmation." },  // Message utilisateur
]);
console.log('---------------------------');
console.log(aiMsg.content);

Résultat de sortie :

---------------------------
J'adore la programmation.

JavaScript : mode natif DashScope

Utilisez la classe d'intégration ChatAlibabaTongyi du paquet @langchain/community.

Installez d'abord les dépendances :

Exemple

npm install @langchain/community @langchain/core

Exemple de code :

Exemple

import { ChatAlibabaTongyi } from "@langchain/community/chat_models/alibaba_tongyi";
import { HumanMessage } from "@langchain/core/messages";

// Le modèle par défaut est qwen-turbo ; seule la clé API est nécessaire
const qwenTurbo = new ChatAlibabaTongyi({
  alibabaApiKey: process.env.DASHSCOPE_API_KEY,  // Lire la clé API depuis une variable d'environnement (obligatoire)
});

// Utilisez qwen-plus, et vous pouvez en outre spécifier des paramètres de génération tels que temperature
const qwenPlus = new ChatAlibabaTongyi({
  model: "qwen-plus",  // Nom du modèle (obligatoire)
  temperature: 1,  // Température de génération ; plus la valeur est grande, plus la sortie est divergente
  alibabaApiKey: process.env.DASHSCOPE_API_KEY,  // Lire la clé API depuis une variable d'environnement (obligatoire)
});

const messages = [new HumanMessage("Hello")];

// Appeler les deux modèles séparément et afficher les résultats
const res = await qwenTurbo.invoke(messages);
const res2 = await qwenPlus.invoke(messages);

console.log('---------------------------');
console.log(res.content);
console.log('---------------------------');
console.log(res2.content);

Java : mode compatible OpenAI (LangChain4j)

L'écosystème Java utilise le framework LangChain4j pour se connecter à Bailian via le module langchain4j-open-ai.

LangChain4j 1.0.0-beta3 nécessite Java 17 ou une version supérieure.

La compilation avec Java 11 signalera l'erreur "Unsupported class file major version 61". La mise à niveau du JDK résoudra ce problème.

Ajoutez la dépendance à pom.xml :

<!-- 文件路径：pom.xml -->
<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-open-ai</artifactId>
    <version>1.0.0-beta3</version>
</dependency>

Exemple de code :

Exemple

import dev.langchain4j.data.message.SystemMessage;
import dev.langchain4j.data.message.UserMessage;
import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.openai.OpenAiChatModel;

public class LangChainOpenAITest {
    public static void main(String[] args) {
        // Créer un modèle de chat, réutiliser le protocole OpenAI pour se connecter à Bailian
        ChatLanguageModel model = OpenAiChatModel.builder()
                .apiKey(System.getenv("DASHSCOPE_API_KEY"))  // Lire la clé API depuis la variable d'environnement (obligatoire)
                .baseUrl("https://dashscope.aliyuncs.com/compatible-mode/v1")  // Adresse compatible OpenAI de Bailian (obligatoire)
                .modelName("qwen-plus")  // Nom du modèle (obligatoire)
                .build();

        SystemMessage systemMessage = SystemMessage.from("Vous êtes un expert en psychologie");  // Message système, définir le rôle
        UserMessage userMessage = UserMessage.from("Bonjour");  // Message utilisateur

        System.out.println(model.chat(systemMessage, userMessage).aiMessage().text());
    }
}

Java : DashScope en mode natif (LangChain4j)

Utilisez le module langchain4j-community-dashscope, qui prend en charge les appels réguliers et les appels en streaming.

Ajoutez la dépendance à pom.xml :

<!-- 文件路径：pom.xml -->
<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-community-dashscope</artifactId>
    <version>1.0.0-beta3</version>
</dependency>

Exemple de code (appel régulier et appel en streaming) :

Exemple

import dev.langchain4j.community.model.dashscope.QwenChatModel;
import dev.langchain4j.community.model.dashscope.QwenStreamingChatModel;
import dev.langchain4j.data.message.ChatMessage;
import dev.langchain4j.data.message.SystemMessage;
import dev.langchain4j.data.message.UserMessage;
import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.chat.StreamingChatLanguageModel;
import dev.langchain4j.model.chat.request.ChatRequest;
import dev.langchain4j.model.chat.response.ChatResponse;
import dev.langchain4j.model.chat.response.StreamingChatResponseHandler;

public class LangChainDashScopeTest {
    public static void main(String[] args) {
        chatLanguageModelTest();  // Appel normal
// streamingChatLanguageModelTest(); // Appel en streaming, décommenter si nécessaire
    }

    // Appel normal : renvoie le résultat complet en une seule fois
    public static void chatLanguageModelTest() {
        ChatLanguageModel qwenModel = QwenChatModel.builder()
                .apiKey(System.getenv("DASHSCOPE_API_KEY"))  // Lire la clé API depuis la variable d'environnement (obligatoire)
                .modelName("qwen-plus")  // Nom du modèle (obligatoire)
                .build();

        // Construire la requête, les messages sont disposés dans l'ordre chronologique
        ChatRequest request = ChatRequest.builder()
                .messages(new ChatMessage[]{
                        SystemMessage.from("Vous êtes un expert en psychologie"),  // Message système
                        UserMessage.from("Bonjour")  // Message utilisateur
                })
                .build();
        System.out.println(qwenModel.chat(request).aiMessage().text());
    }

    // Appel en streaming : recevoir le texte généré segment par segment
    public static void streamingChatLanguageModelTest() {
        StreamingChatLanguageModel model = QwenStreamingChatModel.builder()
                .apiKey(System.getenv("DASHSCOPE_API_KEY"))
                .modelName("qwen-plus")
                .build();

        model.chat("Bonjour", new StreamingChatResponseHandler() {
            @Override
            public void onPartialResponse(String s) {  // Callback une fois pour chaque segment généré
                System.out.println(s);
            }

            @Override
            public void onCompleteResponse(ChatResponse chatResponse) {  // Génération terminée
                System.out.println("Conversation terminée");
                System.exit(0);
            }

            @Override
            public void onError(Throwable throwable) {  // Une exception s'est produite
                System.out.println("Une exception s'est produite");
                System.exit(0);
            }
        });
    }
}

LangChain4j fournit également un Spring Boot Starter. Vous n'avez pas besoin de créer manuellement les objets de modèle ; il suffit de configurer dans application.properties.

Exemple

# Chemin du fichier : application.properties
# Clé API (obligatoire)
langchain4j.open-ai.chat-model.api-key=${DASHSCOPE_API_KEY}
# Nom du modèle (obligatoire)
langchain4j.open-ai.chat-model.model-name=qwen-plus
# Adresse de l'API compatible OpenAI (obligatoire)
langchain4j.open-ai.chat-model.base-url=https://dashscope.aliyuncs.com/compatible-mode/v1
# Port du service
server.port=9000

Les éléments de configuration du Starter natif DashScope ont les mêmes noms. Il suffit de changer le préfixe en langchain4j.community.dashscope.chat-model, et il n'est pas nécessaire de configurer base-url.

Remarques / Questions fréquentes

Pour les problèmes rencontrés lors de l'intégration, vous pouvez les localiser rapidement en vous référant à la liste de contrôle ci-dessous.

Exigences de version Java

LangChain4j 1.0.0-beta3 nécessite Java 17 ou une version ultérieure.

La compilation avec Java 11 signalera "Unsupported class file major version 61". La mise à niveau du JDK résoudra ce problème.

Le mode compatible OpenAI ne prend en charge que certains modèles

L'API compatible OpenAI ne prend en charge que certains modèles Bailian. Consultez la documentation officielle pour la liste complète.

Si le modèle appelé ne fait pas partie de la plage prise en charge, passez au mode natif DashScope.

Dimensions par défaut des vecteurs d'embedding

Lors de l'appel de text-embedding-v3 / v4 via LangChain, ils produisent par défaut des vecteurs de 1024 dimensions, et la dimension ne peut pas être spécifiée manuellement.

Lors de la création de tables de base de données, veuillez réserver un champ vectoriel de 1024 dimensions.

Sécurité de la clé API

Ne codez pas en dur la clé API dans le code ; injectez-la uniformément via la variable d'environnement DASHSCOPE_API_KEY.

Pour les environnements de production, il est recommandé d'utiliser conjointement Alibaba Cloud Key Management Service (KMS).

Liens de référence

La documentation officielle suivante peut vous aider à comprendre les détails pertinents :

SujetLien
Obtenir une clé APIhttps://help.aliyun.com/zh/model-studio/get-api-key
Configurer les variables d'environnementhttps://help.aliyun.com/zh/model-studio/configure-api-key-through-environment-variables
Liste des modèles Bailianhttps://help.aliyun.com/zh/model-studio/getting-started/models
Liste des modèles compatibles OpenAIhttps://help.aliyun.com/zh/model-studio/compatibility-of-openai-with-dashscope
Documentation Python ChatOpenAIhttps://python.langchain.com/docs/integrations/chat/openai/
Documentation Python OpenAIEmbeddingshttps://python.langchain.com/docs/integrations/text_embedding/openai/
Documentation Python ChatTongyihttps://python.langchain.com/docs/integrations/chat/tongyi/
Documentation LangChain4j DashScopehttps://docs.langchain4j.dev/integrations/language-models/dashscope
Autres extensions