Intégration de l'API Baichuan avec LangChain et LlamaIndex pour les pipelines RAG de documents d'entreprise en chinois

La mise en place de pipelines de génération augmentée par récupération (RAG) appliqués aux documents d'entreprise en langue chinoise confronte les ingénieurs backend à des contraintes techniques particulières que les architectures logicielles occidentales traditionnelles ne résolvent pas efficacement. Le chinois ne comporte pas d'espaces pour délimiter les mots, les contrats et manuels de conformité contiennent des formulations juridiques et des clauses hautement codifiées, et les modèles d'embedding multilingues généralistes souffrent fréquemment d'une fragmentation excessive des sous-tokens (token inflation), ce qui réduit la pertinence sémantique et le taux de rappel des recherches.

Baichuan AI propose des modèles de fondation nativement entraînés sur d'importants corpus d'entreprise en chinois : Baichuan4 et Baichuan3-Turbo pour le raisonnement et la synthèse, ainsi que Baichuan-Text-Embedding (vecteurs denses de 1024 dimensions) pour la recherche vectorielle. La plateforme Baichuan fournissant une interface REST compatible avec les spécifications d'OpenAI sur https://api.baichuan-ai.com/v1, les développeurs backend peuvent l'intégrer à la fois dans LangChain et LlamaIndex au moyen de connecteurs communautaires ou de passerelles compatibles standards.

Ce guide présente l'architecture recommandée, les règles de découpage textuel (chunking) adaptées au chinois et les implémentations Python complètes pour des environnements en production.

1. Prérequis et spécifications de l'API

Avant de mettre en place l'ingestion documentaire, créez une clé d'API sur le portail développeur de Baichuan Intelligent et configurez-la dans les variables d'environnement de votre système :

export BAICHUAN_API_KEY="your-baichuan-api-key"

Installez les bibliothèques d'orchestration et la base de données vectorielle :

pip install langchain-community langchain-core langchain-openai \
            llama-index-core llama-index-llms-openai-like llama-index-embeddings-openai \
            chromadb pydantic

Paramètres essentiels de l'API Baichuan :

• Base URL : https://api.baichuan-ai.com/v1
• Complétion de chat : POST /v1/chat/completions (Modèles : Baichuan4, Baichuan4-Air, Baichuan3-Turbo)
• Génération d'embeddings : POST /v1/embeddings (Modèle : Baichuan-Text-Embedding)

2. Découpage textuel des documents d'entreprise en chinois

Les méthodes de découpage basées sur les espaces isolent les caractères de façon aléatoire et brisent la structure des clauses contractuelles ou des codes d'inventaire. Le découpage d'un texte en chinois doit s'effectuer de manière récursive en accordant la priorité aux sauts de paragraphe et aux ponctuations de fin de phrase (。, ！, ？, ；).

Contrainte d'infrastructure majeure : le modèle Baichuan-Text-Embedding impose une limite stricte de 512 tokens par requête. Afin d'éviter les erreurs 400 Bad Request lors des indexations massives, il est recommandé de calibrer les fragments entre 350 et 400 caractères, avec un chevauchement (overlap) de 40 à 50 caractères.

from langchain_text_splitters import RecursiveCharacterTextSplitter

def create_chinese_document_splitter(chunk_size: int = 400, chunk_overlap: int = 50):
    """
    Découpeur récursif optimisé pour les contrats et procédures d'entreprise en chinois.
    """
    return RecursiveCharacterTextSplitter(
        chunk_size=chunk_size,
        chunk_overlap=chunk_overlap,
        separators=[
            "\n\n",      # Sauts de paragraphe
            "\n",        # Sauts de ligne
            "。",        # Point chinois
            "！",        # Point d'exclamation
            "？",        # Point d'interrogation
            "；",        # Point-virgule (courant dans les sous-clauses)
            " ",         # Espace
            ""           # Repli caractère par caractère
        ]
    )

3. Implémentation avec LangChain (LCEL + Recherche dense)

Avec LangChain, il est possible d'utiliser les classes dédiées de langchain_community (ChatBaichuan, BaichuanTextEmbeddings) ou d'instancier langchain_openai en adaptant openai_api_base. Cette seconde approche s'avère particulièrement robuste en production grâce à la prise en charge native du streaming, de l'asynchronisme et de la syntaxe LCEL (LangChain Expression Language).

Pipeline RAG complet sous LangChain

import os
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_community.vectorstores import Chroma
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_core.output_parsers import StrOutputParser
from langchain_core.documents import Document

# 1. Initialisation des composants Baichuan
BAICHUAN_BASE_URL = "https://api.baichuan-ai.com/v1"
api_key = os.environ.get("BAICHUAN_API_KEY")

embeddings = OpenAIEmbeddings(
    model="Baichuan-Text-Embedding",
    openai_api_base=BAICHUAN_BASE_URL,
    openai_api_key=api_key,
    check_embedding_ctx_length=False  # Désactive la vérification contextuelle propre à OpenAI
)

llm = ChatOpenAI(
    model="Baichuan4",
    openai_api_base=BAICHUAN_BASE_URL,
    openai_api_key=api_key,
    temperature=0.1,  # Température basse pour une stricte fidélité documentaire
    streaming=True
)

# 2. Ingestion d'exemples de règlements internes
raw_docs = [
    Document(
        page_content="第十三条 采购付款管理规范：对于超过人民币50万元的设备采购合同，供应商必须提供全额增值税专用发票后，财务部方可安排第二笔30%的进度款支付。项目初验合格前，累计付款比例不得超过合同总额的80%。",
        metadata={"source": "采购管理制度2024.pdf", "department": "Finance"}
    ),
    Document(
        page_content="第二十四条 差旅报销标准：研发部门员工赴一类城市（北京、上海、广州、深圳）出差，住宿费上限为每人每天550元，餐饮补贴为每人每天120元，按实际出差自然天数核算。",
        metadata={"source": "员工差旅规范v3.pdf", "department": "HR"}
    )
]

splitter = create_chinese_document_splitter(chunk_size=400, chunk_overlap=40)
chunked_docs = splitter.split_documents(raw_docs)

# 3. Indexation dans Chroma
vectorstore = Chroma.from_documents(
    documents=chunked_docs,
    embedding=embeddings,
    collection_name="enterprise_knowledge"
)
retriever = vectorstore.as_retriever(search_kwargs={"k": 2})

# 4. Modèle de prompt orienté conformité
system_prompt = (
    "你是一个严谨的企业知识库助手。请严格根据以下检索到的参考文档回答用户的问题。\n"
    "如果参考文档中没有提供明确信息，请直接回答'依据现有内部制度未查到相关说明'，严禁虚构或主观臆测。\n\n"
    "【参考文档】：\n{context}"
)

prompt = ChatPromptTemplate.from_messages([
    ("system", system_prompt),
    ("human", "{question}")
])

def format_docs(docs):
    return "\n\n".join(f"[{doc.metadata.get('source', '未知')}] {doc.page_content}" for doc in docs)

# 5. Construction de la chaîne LCEL
rag_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | prompt
    | llm
    | StrOutputParser()
)

# 6. Exécution de la requête
if __name__ == "__main__":
    query = "50万元以上的设备采购合同，第二笔进度款支付的前提条件是什么？"
    response = rag_chain.invoke(query)
    print("Réponse générée :\n", response)

4. Implémentation avec LlamaIndex (OpenAILike et découpage personnalisé)

Dans l'écosystème modulaire de LlamaIndex (v0.10+), la classe générique OpenAI vérifie les identifiants de modèles officiels. Pour connecter l'API Baichuan, on utilise la classe OpenAILike issue de llama-index-llms-openai-like, tandis que le module de vectorisation s'appuie sur OpenAIEmbedding paramétré avec api_base.

Pipeline RAG complet sous LlamaIndex

import os
from llama_index.core import Settings, VectorStoreIndex, Document
from llama_index.core.node_parser import SentenceSplitter
from llama_index.llms.openai_like import OpenAILike
from llama_index.embeddings.openai import OpenAIEmbedding

# 1. Configuration globale de LlamaIndex
BAICHUAN_BASE_URL = "https://api.baichuan-ai.com/v1"
api_key = os.environ.get("BAICHUAN_API_KEY")

Settings.llm = OpenAILike(
    model="Baichuan4",
    api_base=BAICHUAN_BASE_URL,
    api_key=api_key,
    is_chat_model=True,
    temperature=0.1
)

Settings.embed_model = OpenAIEmbedding(
    model="Baichuan-Text-Embedding",
    api_base=BAICHUAN_BASE_URL,
    api_key=api_key
)

# 2. Découpage basé sur les fins de phrases en chinois
Settings.node_parser = SentenceSplitter(
    chunk_size=400,
    chunk_overlap=40,
    separator="。"
)

# 3. Indexation des documents
documents = [
    Document(
        text="第七章 核心数据安全防护要求：涉及生产数据库导出操作必须提前48小时提交工单，经信息安全负责人与业务分管领导双重审批后方可在堡垒机中执行。导出文件须启用国密SM4算法加密并在3天内自动销毁。",
        metadata={"category": "SecOps", "author": "Security Committee"}
    )
]

index = VectorStoreIndex.from_documents(documents)

# 4. Création du moteur de requête
query_engine = index.as_query_engine(
    similarity_top_k=2,
    system_prompt=(
        "你代表企业信息化与安全管理委员会回答技术咨询。"
        "请严格根据检索到的规范作答，列出具体审核流程及技术加密要求。"
    )
)

if __name__ == "__main__":
    response = query_engine.query("导出生产环境数据库需要满足哪些审批与安全条件？")
    print("Résultat LlamaIndex :\n", str(response))

5. Recommandations d'ingénierie pour les déploiements d'entreprise

Pour garantir la fiabilité d'un système RAG reposant sur Baichuan en environnement d'entreprise, plusieurs mesures d'architecture sont recommandées :

1. Recherche hybride (Vectorielle + BM25)

Les embeddings sémantiques sont très performants pour capter les synonymes, mais peuvent manquer de rigueur face à des numéros de clauses stricts (ex. « Article 13 alinéa 2 »), des codes de pièces ou des références d'équipements. Combiner Baichuan-Text-Embedding avec un moteur BM25 ou Elasticsearch via EnsembleRetriever garantit un meilleur taux de rappel.

2. Validation préventive du plafond de 512 tokens

Puisque Baichuan-Text-Embedding rejette les requêtes dépassant 512 tokens, des extraits issus de tableaux volumineux ou de textes OCR non ponctués peuvent bloquer l'indexation par lots. Intégrez un filtre en amont pour mesurer le nombre de tokens et redécouper automatiquement tout fragment excédant la limite autorisée.

3. Gestion des quotas d'appels et tolérance aux pannes

Lors de l'indexation initiale d'une volumétrie documentaire importante, le plafond de requêtes par minute (RPM) de la plateforme peut être atteint. Implémentez un mécanisme de réessai à intervalle exponentiel (tenacity) et limitez la concurrence avec des sémaphores asynchrones.

4. Réduction des hallucinations et traçabilité

Dans les contextes de conformité et de droit du travail, une fausse information présente des risques opérationnels réels. Imposez une consigne stricte de rejet si la réponse ne figure pas dans les sources, et joignez systématiquement les métadonnées (nom de fichier, version, page) dans la restitution afin de permettre aux utilisateurs de vérifier le texte source.

Références

• 百川大模型-汇聚世界知识 创作妙笔生花-百川智能
• 百川大模型-汇聚世界知识 创作妙笔生花-百川智能
• LlamaIndex Framework, by the makers of LlamaParse | Developer Documentation
• Retrieval Augmented Generation (RAG) with Deep Agents - Docs by LangChain
• GitHub - baichuan-inc/baichuan-mcp-servers: 百川智能官方mcp server集合 · GitHub