Integración de LangChain con Alibaba Bailian

LangChain es el marco de desarrollo de aplicaciones de grandes modelos de lenguaje más popular en la actualidad. A través de interfaces de componentes unificadas, ayuda a los desarrolladores a construir rápidamente indicaciones (prompts), modelos, cadenas de herramientas y aplicaciones de agentes.

Alibaba Cloud Bailian (DashScope) es la plataforma de servicios de grandes modelos de lenguaje de Alibaba Cloud, que ofrece modelos de chat de la serie Tongyi Qianwen (qwen), modelos de incrustación de texto y modelos de reranking.

Este artículo explica cómo integrar los modelos de Bailian con LangChain, cubriendo tres grandes categorías: modelos de chat, modelos de incrustación de texto y modelos de reranking, y proporciona ejemplos completos en Python, JavaScript y Java.

Preparación previa

Necesitamos activar el servicio de modelos Bailian de Alibaba Cloud y obtener una API-KEY.

Primero podemos usar la cuenta principal de Alibaba Cloud para acceder a la plataforma de servicios de modelos Bailian:https://bailian.console.aliyun.com/Luego haga clic en «Iniciar sesión» en la esquina superior derecha. Una vez iniciada la sesión, haga clic en el icono de engranaje ⚙️ de la esquina superior derecha, seleccione API key y cópiela. Si no tiene una, también puede crear una API key:

Antes de comenzar, comprendamos dos conceptos clave: la «clase de integración de modelos» de LangChain y los «dos modos de integración» de Bailian.

Clase de integración de modelos

LangChain encapsula los modelos de diferentes proveedores en una «clase de integración» unificada.

El código de la aplicación se programa contra una interfaz unificada. Al cambiar de proveedor, solo es necesario reemplazar la clase de integración y los parámetros; la lógica de negocio casi no requiere modificaciones.

Tomando el modelo de chat como ejemplo, en Python existen dos clases de integración, ChatOpenAI y ChatTongyi, que corresponden respectivamente al modo compatible con OpenAI y al modo nativo de DashScope de Bailian.

Dos modos de integración

Bailian ofrece dos conjuntos de protocolos de integración. Elegir un protocolo diferente corresponde a diferentes clases de integración de LangChain.

Modo compatible con OpenAIEl protocolo de interfaz es consistente con OpenAI. Cualquier framework que admita el protocolo OpenAI puede conectarse directamente, con el menor costo de integración.

Modo nativo de DashScopeUtiliza el protocolo DashScope propio de Bailian y puede invocar todos los modelos de generación de texto de Bailian, incluidos los modelos personalizados desplegados.

La arquitectura general de integración se muestra en la siguiente figura:

LangChain 集成阿里云百炼架构图

La denominada «interfaz compatible con OpenAI» se refiere a que el protocolo de interfaz HTTP del proveedor es consistente con OpenAI.

Siempre que el protocolo sea compatible, cualquier código o herramienta escrita para OpenAI se puede reutilizar directamente; solo es necesario modificar la dirección de la interfaz.

Configurar variables de entorno

Todos los lenguajes y métodos de integración utilizan de manera uniforme variables de entornoDASHSCOPE_API_KEYpara guardar la clave.

Linux / macOS: exporte en la terminal:

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

Windows (CMD): método de configuración:

set DASHSCOPE_API_KEY=sk-你的百炼APIKey

Se recomienda escribir el comando de exportación en el archivo de configuración del shell (por ejemplo, ~/.bashrc, ~/.zshrc), para evitar configurarlo cada vez que se abre la terminal.

Configuración mediante archivo .env (recomendado)

La práctica más recomendable es escribir la clave en el archivo .env de la raíz del proyecto y, junto con python-dotenv, cargarla automáticamente en las variables de entorno.

La clave se separa del código; con .gitignore se evita la confirmación accidental, y en la colaboración de varias personas es fácil que cada uno mantenga la suya.

Cree el archivo .env en la raíz del proyecto:

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

Por ejemplo, en nuestro proyecto de pruebaejemplo-langchain-testcree.envel archivo y agregue la configuración:

Instale python-dotenv:

pip install python-dotenv

Cargue el archivo .env al comienzo del código Python:

Ejemplo

from dotenv import load_dotenv

load_dotenv()  # Lee el archivo .env de la raíz del proyecto e inyéctalo como variable de entorno

Después de la carga, el código os.getenv("DASHSCOPE_API_KEY") puede leer la clave, con el mismo efecto que exportarla manualmente.

En los ejemplos de la sección «Modelo de chat», ya se ha mostrado este método de carga.

.env es un archivo sensible; agréguelo a .gitignore (escriba una línea `.env`) para evitar que la clave se envíe al repositorio.

Reemplace la clave de los ejemplos por una Key real y nunca la comparta con otras personas.

Comparación de los dos métodos de integración

Primero vea una tabla comparativa y luego elija el método de integración según sus necesidades.

Elemento de comparaciónModo compatible con OpenAIModo nativo de DashScope
Principio de integraciónReutiliza la clase de integración del protocolo OpenAIUtiliza el SDK nativo de DashScope
Modelos compatiblesSolo algunos modelosTodos los modelos de generación de texto y los modelos desplegados
Clase de integración en PythonChatOpenAIChatTongyi
Clase de integración en JavaScriptChatOpenAIChatAlibabaTongyi
Clase de integración en JavaOpenAiChatModelQwenChatModel
Escenarios de aplicaciónTiene código de OpenAI que necesita migrarse rápidamenteNecesita capacidades completas del modelo o usar modelos desplegados

Ambos modos utilizan el mismo dominio dashscope.aliyuncs.com; la diferencia está en la ruta: la ruta del modo compatible con OpenAI es /compatible-mode/v1, y la ruta del modo nativo de DashScope está incorporada en el SDK.

Modelo de chat (Chat Model)

El modelo de chat es uno de los tipos de modelos más utilizados; se usa para tareas como diálogos de múltiples turnos, preguntas y respuestas, generación de contenido, etc.

A continuación se presentan los métodos de integración para cada lenguaje. El modelo de ejemplo usa uniformemente qwen-plus; se puede cambiar según sea necesario.

Python: modo compatible con OpenAI

Utilice la clase de integración ChatOpenAI del paquete langchain_openai para llamar a Bailian como un servicio OpenAI.

Primero instale las dependencias:

pip install langchain_openai

Código de ejemplo:

Ejemplo

from langchain_openai import ChatOpenAI
from dotenv import load_dotenv  # Lee la configuración del archivo .env
import os

load_dotenv()  # Carga la clave y otras variables de entorno desde el archivo .env de la raíz del proyecto

# Crea la instancia del modelo de chat y se conecta a Bailian mediante el protocolo compatible con OpenAI
chatLLM = ChatOpenAI(
    api_key=os.getenv("DASHSCOPE_API_KEY"),  # Lee la API Key de Bailian desde la variable de entorno (obligatorio)
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",  # Dirección de la interfaz compatible con OpenAI de Bailian (obligatorio)
    model="qwen-plus",  # Nombre del modelo (obligatorio); aquí se usa qwen-plus como ejemplo
    # Otros parámetros opcionales: temperature (temperatura de generación), max_tokens (longitud máxima de salida), etc.
)

# Construye la lista de mensajes para el diálogo de múltiples turnos
messages = [
    {"role": "system", "content": "You are a helpful assistant."},  # Mensaje del sistema, establece el rol del asistente
    {"role": "user", "content": "¿Quién eres?"},  # Mensaje del usuario, contenido de la pregunta
]

# Realiza la llamada y devuelve el objeto de respuesta estructurada
response = chatLLM.invoke(messages)
print(response.model_dump_json())

Resultado de salida (omitiendo algunos campos):

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

Después de una llamada exitosa, se devuelve un objeto AIMessage, y model_dump_json() puede serializarlo a JSON para ver la respuesta completa.

Python: modo nativo de DashScope

Use la clase de integración ChatTongyi del paquete langchain-community, que sigue el protocolo nativo de DashScope y admite salida en streaming.

ChatTongyi proviene del paquete comunitario langchain-community; este paquete y dashscope han dejado de mantenerse.

En proyectos nuevos se recomienda priorizar la integración con ChatOpenAI mediante el modo compatible con OpenAI; solo considere este método cuando necesite capacidades nativas de DashScope (como el despliegue de modelos).

Primero instale las dependencias:

pip install langchain-community dashscope

Código de ejemplo:

Ejemplo

from langchain_community.chat_models.tongyi import ChatTongyi
from langchain_core.messages import HumanMessage
from dotenv import load_dotenv  # Leer la configuración del archivo .env
import os

load_dotenv()  # Cargar variables de entorno como claves desde el .env en la raíz del proyecto

# Crear el modelo de chat Qwen usando el protocolo nativo de DashScope
chatLLM = ChatTongyi(
    model="qwen-plus",  # Nombre del modelo (obligatorio)
    dashscope_api_key=os.getenv("DASHSCOPE_API_KEY"),  # Leer la API Key desde la variable de entorno (obligatorio)
    streaming=True,  # Habilitar salida en streaming
)

# Llamada en streaming, recibe e imprime el contenido de la respuesta por fragmentos
res = chatLLM.stream([HumanMessage(content="hi")], streaming=True)
for r in res:
    print("chat resp:", r.content)

Resultado de salida:

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

La salida en streaming permite que el modelo devuelva el contenido por fragmentos mientras genera, ideal para interfaces de chat con efecto de máquina de escribir.

Modelo de incrustación de texto (Embedding Model)

Los modelos de embeddings convierten texto en vectores semánticos; son la base de aplicaciones como RAG (generación aumentada por recuperación) y búsqueda semántica.

Selección de modelos

Bailian ofrece múltiples versiones de modelos de embeddings. Puede comparar su rendimiento con las métricas MTEB y CMTEB; cuanto mayor sea el valor, mejor.

ModeloMTEBMTEB (tarea de recuperación)CMTEBCMTEB (tarea de recuperación)
text-embedding-v158.3045.4759.8456.59
text-embedding-v260.1349.4962.1762.78
text-embedding-v3 (1024 dimensiones)63.3955.4168.9273.23
text-embedding-v4 (1024 dimensiones)68.3659.3070.1473.98

text-embedding-v3 y text-embedding-v4 no permiten especificar la dimensión del vector al llamarlos mediante LangChain; por defecto generan un vector de 1024 dimensiones.

Cuanto mayor sea la versión, mejor será el efecto; priorice v4.

Ejemplo en Python

La interfaz de embeddings de Bailian es compatible con la especificación de la API de OpenAI. Simplemente use la clase de integración OpenAIEmbeddings del paquete langchain-openai y apunte base_url al endpoint compatible de Bailian.

No es necesario instalar los paquetes langchain-community y dashscope, que han dejado de mantenerse.

Primero instale las dependencias:

pip install langchain-openai

OpenAIEmbeddings requiere tres parámetros clave: model (nombre del modelo de embeddings), api_key (clave de Bailian) y base_url (endpoint compatible con OpenAI de Bailian).

base_url es fijo: https://dashscope.aliyuncs.com/compatible-mode/v1, igual que el endpoint compatible para modelos de chat.

Código de ejemplo:

Ejemplo

from langchain_openai import OpenAIEmbeddings
from dotenv import load_dotenv  # Leer la configuración del archivo .env
import os

load_dotenv()  # Cargar variables de entorno como claves desde el .env en la raíz del proyecto

# Crear una instancia del modelo de embeddings, conectando con Bailian mediante el protocolo compatible con OpenAI
# chunk_size=10: la interfaz Embedding de Bailian acepta como máximo 10 textos por solicitud,
# OpenAIEmbeddings agrupa 1000 elementos por defecto; si la base de conocimiento es un poco grande, se superará el límite y dará error.
embeddings = OpenAIEmbeddings(
    model="text-embedding-v4",  # Nombre del modelo de embeddings (obligatorio), aquí se usa v4 como ejemplo
    api_key=os.getenv("DASHSCOPE_API_KEY"),  # Leer la API Key de Bailian desde la variable de entorno (obligatorio)
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",  # Endpoint compatible con OpenAI de Bailian (obligatorio)
    check_embedding_ctx_length=False,
    chunk_size=10,
)

# Vectorizar un único texto de consulta
text = "This is a test document."
query_result = embeddings.embed_query(text)
print("Longitud del vector de texto:", len(query_result), sep='')

# Vectorizar múltiples documentos en lote
doc_results = embeddings.embed_documents(
    [
        "Hi there!",
        "Oh, hello!",
        "What's your name?",
        "My friends call me World",
        "Hello World!"
    ])
print("Número de vectores de texto:", len(doc_results), ", longitud del vector de texto:", len(doc_results[0]), sep='')

Resultado de salida:

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

embed_query se usa para vectorizar la consulta del usuario; embed_documents se usa para vectorizar en lote los documentos candidatos. Solo si ambos generan vectores con la misma dimensión se puede calcular la similitud.

Modelo de reranking (Reranker Model)

Los modelos de reranking realizan una segunda puntuación y ordenación de los resultados de recuperación, lo que puede mejorar significativamente la calidad de las respuestas en aplicaciones RAG.

Parámetros del modelo

Bailian ofrece los siguientes modelos de reranking; elija según el idioma, el costo y el escenario:

ModeloNúmero máximo de documentosEntrada máxima por elementoIdiomas compatiblesPrecio unitario (por cada mil tokens)Escenarios aplicables
qwen3-vl-rerank1008,000 Token33 idiomas principales, incluidos chino, inglés, japonés y coreanoImagen 0.0018 yuanes / texto 0.0007 yuanesAgrupación de imágenes, búsqueda multimodal, recuperación de imágenes
qwen3-rerank5004,000 TokenMás de 100 idiomas, incluidos chino, inglés, español, francés, japonés y coreano0.0005 yuanesBúsqueda semántica de texto, aplicaciones RAG
gte-rerank-v2—30,000 TokenMás de 50 idiomas, incluidos chino, inglés, japonés, coreano y tailandés0.0008 yuanesReranking de textos largos

Ejemplo en Python

Use la clase de integración DashScopeRerank del paquete langchain-community.

Este ejemplo utiliza DashScopeRerank del paquete comunitario langchain-community.

langchain-community y dashscope han dejado de mantenerse. En proyectos nuevos, preste atención a los métodos de integración alternativos proporcionados oficialmente por Bailian.

Primero instale las dependencias:

pip install langchain-community dashscope

Código de ejemplo:

Ejemplo

from langchain_community.document_compressors.dashscope_rerank import DashScopeRerank
from dotenv import load_dotenv  # Leer la configuración del archivo .env

load_dotenv()  # Cargar variables de entorno como claves desde el .env en la raíz del proyecto

# Simular la lista de textos candidatos devuelta por la recuperación
sequence = ["ejemplo es un sitio chino de aprendizaje que ofrece tutoriales de programación", "text2", "text3"]

# Crear una instancia del modelo de reranking
reranker = DashScopeRerank(
    model="gte-rerank-v2",  # Nombre del modelo de reranking (obligatorio)
)

# Reordenar los textos candidatos según la consulta y devolver el top_n con mayor puntuación
print(reranker.rerank(documents=sequence, query="¿Qué es Python?", top_n=2))

El método rerank vuelve a puntuar y ordenar los documentos candidatos según la query; top_n especifica el número de elementos devueltos y se usa comúnmente en la etapa de refinamiento posterior a la recuperación en RAG.

Integración de JavaScript y Java

JavaScript: modo compatible con OpenAI

En el lado de Node.js, use la clase de integración ChatOpenAI del paquete @langchain/openai.

Primero instale las dependencias:

npm install @langchain/openai @langchain/core

Código de ejemplo:

Ejemplo

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

// Crear una instancia del modelo de chat, conectando con Bailian mediante el protocolo compatible con OpenAI
const llm = new ChatOpenAI({
  model: "qwen-plus",  // Nombre del modelo (obligatorio), aquí se usa qwen-plus como ejemplo
  apiKey: process.env.DASHSCOPE_API_KEY,  // Leer la API Key de Bailian desde la variable de entorno (obligatorio)
  configuration: {
    baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1",  // Dirección de la interfaz compatible con OpenAI de Bailian (obligatorio)
  },
});

// Realizar la llamada de diálogo, devuelve el objeto de mensaje de IA
const aiMsg = await llm.invoke([
  { role: "system", content: "You are a helpful assistant that translates English to French. Translate the user sentence." },  // Mensaje del sistema
  { role: "user", content: "I love programming." },  // Mensaje del usuario
]);
console.log('---------------------------');
console.log(aiMsg.content);

Resultado de salida:

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

JavaScript: modo nativo de DashScope

Use la clase de integración ChatAlibabaTongyi del paquete @langchain/community.

Primero instale las dependencias:

Ejemplo

npm install @langchain/community @langchain/core

Código de ejemplo:

Ejemplo

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

// El modelo predeterminado es qwen-turbo; solo necesita proporcionar la API Key
const qwenTurbo = new ChatAlibabaTongyi({
  alibabaApiKey: process.env.DASHSCOPE_API_KEY,  // Leer la API Key desde la variable de entorno (obligatorio)
});

// Usa qwen-plus; también se pueden especificar parámetros de generación como temperature
const qwenPlus = new ChatAlibabaTongyi({
  model: "qwen-plus",  // Nombre del modelo (obligatorio)
  temperature: 1,  // Temperatura de generación; cuanto mayor sea el valor, más divergente es la salida
  alibabaApiKey: process.env.DASHSCOPE_API_KEY,  // Leer la API Key desde la variable de entorno (obligatorio)
});

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

// Llamar a los dos modelos por separado e imprimir los resultados
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: modo compatible con OpenAI (LangChain4j)

El ecosistema Java utiliza el framework LangChain4j y se conecta a Bailian a través del módulo langchain4j-open-ai.

LangChain4j 1.0.0-beta3 requiere Java 17 o superior.

Compilar con Java 11 provocará el error "Unsupported class file major version 61"; actualizar el JDK lo soluciona.

Agregue la dependencia en pom.xml:

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

Código de ejemplo:

Ejemplo

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) {
        // Crear el modelo de chat, reutilizando el protocolo OpenAI para conectarse a Bailian
        ChatLanguageModel model = OpenAiChatModel.builder()
                .apiKey(System.getenv("DASHSCOPE_API_KEY"))  // Leer la API Key desde la variable de entorno (obligatorio)
                .baseUrl("https://dashscope.aliyuncs.com/compatible-mode/v1")  // Dirección compatible con OpenAI de Bailian (obligatorio)
                .modelName("qwen-plus")  // Nombre del modelo (obligatorio)
                .build();

        SystemMessage systemMessage = SystemMessage.from("Eres un experto en psicología");  // Mensaje del sistema, configurar el rol
        UserMessage userMessage = UserMessage.from("Hola");  // Mensaje del usuario

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

Java: modo nativo de DashScope (LangChain4j)

Usa el módulo langchain4j-community-dashscope, compatible con llamadas normales y llamadas en streaming.

Añade la dependencia en pom.xml:

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

Código de ejemplo (llamada normal y llamada en streaming):

Ejemplo

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();  // Llamada normal
// streamingChatLanguageModelTest(); // Llamada en streaming, descomenta según sea necesario
    }

    // Llamada normal: devuelve el resultado completo de una sola vez
    public static void chatLanguageModelTest() {
        ChatLanguageModel qwenModel = QwenChatModel.builder()
                .apiKey(System.getenv("DASHSCOPE_API_KEY"))  // Leer la API Key desde la variable de entorno (obligatorio)
                .modelName("qwen-plus")  // Nombre del modelo (obligatorio)
                .build();

        // Construir la solicitud, los mensajes se ordenan por tiempo
        ChatRequest request = ChatRequest.builder()
                .messages(new ChatMessage[]{
                        SystemMessage.from("Eres un experto en psicología"),  // Mensaje del sistema
                        UserMessage.from("Hola")  // Mensaje del usuario
                })
                .build();
        System.out.println(qwenModel.chat(request).aiMessage().text());
    }

    // Llamada en streaming: recibe el texto generado por fragmentos
    public static void streamingChatLanguageModelTest() {
        StreamingChatLanguageModel model = QwenStreamingChatModel.builder()
                .apiKey(System.getenv("DASHSCOPE_API_KEY"))
                .modelName("qwen-plus")
                .build();

        model.chat("Hola", new StreamingChatResponseHandler() {
            @Override
            public void onPartialResponse(String s) {  // Se llama una vez por cada fragmento generado
                System.out.println(s);
            }

            @Override
            public void onCompleteResponse(ChatResponse chatResponse) {  // Generación completada
                System.out.println("Fin de la conversación");
                System.exit(0);
            }

            @Override
            public void onError(Throwable throwable) {  // Se produjo una excepción
                System.out.println("Se produjo una excepción");
                System.exit(0);
            }
        });
    }
}

LangChain4j también ofrece un Spring Boot Starter, sin necesidad de construir manualmente el objeto del modelo; basta con configurarlo en application.properties.

Ejemplo

# Ruta del archivo: application.properties
# API Key (obligatorio)
langchain4j.open-ai.chat-model.api-key=${DASHSCOPE_API_KEY}
# Nombre del modelo (obligatorio)
langchain4j.open-ai.chat-model.model-name=qwen-plus
# Dirección de interfaz compatible con OpenAI (obligatorio)
langchain4j.open-ai.chat-model.base-url=https://dashscope.aliyuncs.com/compatible-mode/v1
# Puerto del servicio
server.port=9000

La configuración del Starter en el modo nativo DashScope usa los mismos nombres; solo hay que cambiar el prefijo por langchain4j.community.dashscope.chat-model, y no es necesario configurar base-url.

Notas / Preguntas frecuentes

Los problemas encontrados durante la integración se pueden localizar rápidamente con la siguiente lista.

Requisitos de versión de Java

LangChain4j 1.0.0-beta3 requiere Java 17 o superior.

Compilar con Java 11 dará el error Unsupported class file major version 61; basta con actualizar el JDK para solucionarlo.

El modo compatible con OpenAI solo admite algunos modelos

La interfaz compatible con OpenAI solo admite algunos modelos de Bailian; consulta la lista completa en la documentación oficial.

Si el modelo llamado no está en el rango compatible, cambia al modo nativo DashScope.

Dimensión predeterminada del vector de incrustación

text-embedding-v3 / v4, al llamarse a través de LangChain, genera por defecto vectores de 1024 dimensiones, y no se puede especificar manualmente la dimensión.

Al crear la tabla en la base de datos, reserva un campo vectorial de 1024 dimensiones.

Seguridad de la API Key

No codifiques la API Key directamente en el código; inyéctala siempre a través de la variable de entorno DASHSCOPE_API_KEY.

En entornos de producción, se recomienda usar junto con el servicio de gestión de claves de Alibaba Cloud.

Enlaces de referencia

Los siguientes documentos oficiales pueden ayudarte a profundizar en los detalles relevantes:

TemaEnlace
Obtener API Keyhttps://help.aliyun.com/zh/model-studio/get-api-key
Configurar variables de entornohttps://help.aliyun.com/zh/model-studio/configure-api-key-through-environment-variables
Lista de modelos de Bailianhttps://help.aliyun.com/zh/model-studio/getting-started/models
Lista de modelos compatibles con OpenAIhttps://help.aliyun.com/zh/model-studio/compatibility-of-openai-with-dashscope
Documentación de Python ChatOpenAIhttps://python.langchain.com/docs/integrations/chat/openai/
Documentación de Python OpenAIEmbeddingshttps://python.langchain.com/docs/integrations/text_embedding/openai/
Documentación de Python ChatTongyihttps://python.langchain.com/docs/integrations/chat/tongyi/
Documentación de LangChain4j DashScopehttps://docs.langchain4j.dev/integrations/language-models/dashscope
Otras extensiones