Remarques :

Intégrez LangChain, OCI Data Science Notebook, OCI avec OpenSearch et OCI Generative AI pour accélérer le développement de LLM pour la RAG et la recherche conversationnelle

Introduction

Dans ce tutoriel, nous allons découvrir comment LangChain, Oracle Cloud Infrastructure (OCI) Data Science Notebook, OCI avec OpenSearch, OCI Data Science AI Quick Actions (AI Quick Actions) et le service OCI Generative AI s'intègrent de manière transparente pour simplifier le développement d'applications de grands modèles de langage (LLM). Ces outils accélèrent les workflows, améliorent la productivité et permettent un déploiement plus rapide de solutions d'IA de pointe adaptées aux besoins spécifiques de l'entreprise.

Dans le premier tutoriel : Tutoriel 1 : Intégration d'OCI Search avec OpenSearch et LangChain dans OCI Data Science Notebook, nous avons discuté de l'impact transformateur de l'intégration de LangChain, d'OCI avec OpenSearch et de Hugging Face, en montrant comment ces technologies peuvent fonctionner avec OCI Data Science Notebook pour simplifier le développement et la production de solutions de recherche sémantique pour les entreprises. Nous avons détaillé les étapes de configuration de bout en bout pour la configuration d'OCI avec OpenSearch, la configuration du bloc-notes OCI Data Science, la configuration de LangChain avec une session de bloc-notes et le déploiement d'un cas d'utilisation complet pour la recherche sémantique.

S'appuyant sur cette base, ce tutoriel se concentre sur la façon dont l'intégration transparente dans LangChain, OCI avec OpenSearch, AI Quick Actions et OCI Generative AI peut accélérer le développement d'applications LLM pour des cas d'utilisation métier personnalisés. Nous nous pencherons en particulier sur les solutions autour de la recherche conversationnelle, de la génération augmentée de récupération (RAG) et des chatbots qui répondent aux questions, en montrant comment ces outils permettent aux développeurs de relever les défis et de fournir des applications innovantes et évolutives avec un codage minimal.

Remarque : vous trouverez les exemples de code complets pour ce tutoriel dans notre référentiel d'exemples publics ici : Exemples de code de service OCI OpenSearch.

Avantages de l'approche intégrée

La création d'applications avec des LLM implique plusieurs étapes :

Chaque étape peut nécessiter des outils spécialisés, des pipelines complexes et des efforts de développement importants. En intégrant LangChain aux services OCI, les développeurs peuvent relever ces défis de manière holistique, réduisant ainsi la complexité et améliorant la productivité.

Objectifs

Prérequis

Tâche 1 : création d'un projet OCI Data Science et configuration de blocs-notes

OCI Data Science Notebook fournit une plate-forme flexible et interactive pour le développement, le test et le déploiement d'applications d'IA. L'intégration des blocs-notes aux services OCI crée une expérience de développement transparente, réduisant ainsi le besoin d'outils externes. Avec les blocs-notes, vous pouvez :

Pour créer un projet OCI Data Science et configurer un bloc-notes, reportez-vous à Tâche 2 : lancement d'un bloc-notes Jupyter Notebook dans OCI Data Science.

Tâche 2 : installer LangChain

LangChain est l'un des frameworks les plus polyvalents pour le développement d'applications basées sur un LLM. Sa conception modulaire et sa bibliothèque étendue fournissent des abstractions robustes pour :

La capacité de LangChain à interagir de manière transparente avec des services cloud tels qu'OCI Generative AI, OCI avec OpenSearch et OCI Data Science améliore son utilité pour créer des applications d'entreprise. La flexibilité de LangChain permet aux développeurs de prototyper et d'itérer rapidement sur les applications, ce qui le rend idéal pour les solutions RAG et de recherche conversationnelle. Ses intégrations aux services OCI rationalisent davantage le processus de développement, ce qui permet aux développeurs de se concentrer sur la création de valeur. Dans le premier tutoriel, nous avons expliqué comment configurer LangChain avec un environnement de bloc-notes et nous avons passé en revue un exemple complet d'utilisation de LangChain pour traiter des données non structurées, les ingérer dans OCI avec OpenSearch et effectuer une recherche sémantique.

Exécutez la commande suivante dans votre bloc-notes pour configurer LangChain et d'autres bibliothèques de clés.

!pip install -U oci oracle_ads langchain langchain-community  langchain-huggingface  opensearch-py pypdf

Tâche 3 : utilisez LangChain pour prétraiter et fragmenter vos données

Utilisez le code Python suivant.

import os
from langchain.document_loaders import PyPDFLoader, CSVLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
 
# Step 1: Load PDF and CSV Documents
def load_documents():
    # Load PDF Document
    pdf_loader = PyPDFLoader("data/sample_document.pdf")
    pdf_documents = pdf_loader.load()
 
    # Load CSV Document
    csv_loader = CSVLoader(file_path="data/sample_data.csv")
    csv_documents = csv_loader.load()
 
    # Combine both sets of documents
    all_documents = pdf_documents + csv_documents
    return all_documents
 
# Step 2: Split the documents into smaller chunks for better processing
def split_documents(documents):
    text_splitter = RecursiveCharacterTextSplitter(
        chunk_size=1000,
        chunk_overlap=100
    )
    split_docs = text_splitter.split_documents(documents)
    return split_docs
 
 
# Load and process documents
documents = load_documents()
split_docs = split_documents(documents)

Tâche 4 : configurer le modèle d'intégration avec OCI Generative AI Cohere

Le service OCI Generative AI fournit une plate-forme entièrement gérée pour accéder à des LLM de pointe, tels que LLaMA-3 de Cohere et Meta. Il prend en charge les modèles suivants :

La principale différence entre les actions rapides d'IA et OCI Generative AI est que AI Quick Actions dispose d'un catalogue de modèles plus complet et offre beaucoup plus de flexibilité avec l'entraînement des modèles, l'évaluation, le réglage fin et la gestion du cycle de vie. Le principal avantage d'OCI Generative AI est que vous n'avez pas à posséder l'infrastructure qui héberge votre modèle. Vous pouvez utiliser l'adresse générique pour n'importe quel modèle disponible et vous êtes facturé uniquement en fonction du nombre de demandes et du nombre de jetons. En revanche, avec les actions rapides d'IA, bien que vous ayez plus d'autonomie sur votre LLM ou sur toute orchestration et tout cycle de vie de workflow d'IA/ML, vous ne payez que pour le coût de l'infrastructure et vous avez des demandes illimitées.

De plus, le service OCI Generative AI est prêt à utiliser des modèles d'intégration d'entreprise tels que le modèle Cohere Embed V3, conçu pour les données d'entreprise et connu pour fonctionner mieux que les autres modèles de transformateur de phrase préentraînés à partir d'un visage embrassant, en particulier sur les données personnalisées. Il vous suffit d'appeler ce modèle pour générer l'intégration de vos données. Par conséquent, nous pensons que la combinaison d'OCI Generative AI et d'actions rapides d'IA peut vous donner la meilleure valeur pour votre application métier. Vous pouvez appeler l'adresse de modèle d'intégration OCI Generative AI Cohere déjà déployée pour intégrer vos données, et utiliser les actions rapides d'IA pour affiner, tester, évaluer et déployer votre modèle.

LangChain s'intègre de manière transparente à OCI Generative AI et à AI Quick Action, ce qui permet aux développeurs d'appeler des modèles directement à partir de leur environnement OCI. Avec une configuration minimale, les développeurs peuvent commencer à utiliser des modèles préentraînés ou affinés.

Voici un exemple d'utilisation de l'intégration LangChain pour appeler le modèle V3 d'intégration Cohere et l'utiliser pour intégrer vos documents lors de l'ingestion de données.

from langchain_community.embeddings import OCIGenAIEmbeddings

oci_cohere_embedding_model = OCIGenAIEmbeddings(
    model_id="cohere.embed-english-v3.0",
    service_endpoint="https://inference.generativeai.us-chicago-1.oci.oraclecloud.com",
    compartment_id="<>YOUR-COMPARTMENT-OCID",
    auth_type="RESOURCE_PRINCIPAL",
    model_kwargs={"input_type": "SEARCH_DOCUMENT"}
)

Tâche 5 : configurer OCI avec OpenSearch avec LangChain pour activer les workflows RAG

RAG s'appuie sur des systèmes de récupération rapides et précis. OCI avec le service OpenSearch fournit l'infrastructure pour :

La fonctionnalité de banque de vecteurs de LangChain s'intègre à OCI avec OpenSearch pour prendre en charge les workflows RAG. Les développeurs peuvent utiliser les incorporations d'OCI Generative AI pour indexer et extraire efficacement des données à partir d'OCI avec OpenSearch.

Utilisez le code Python suivant.

from langchain.vectorstores import OpenSearchVectorSearch
import oci
 
# setup your script to use Resource principal for authentication
auth_provider = oci.auth.signers.get_resource_principals_signer()
auth = ("username", "password")
AUTH_TYPE="RESOURCE_PRINCIPAL"
opensearch_url="https://amaaaaaallb3......................opensearch.us-ashburn-1.oci.oraclecloud.com:9200"   // replace this whole value your opensearch url. Be sure sure to have the :9200 port in your url
 
# Initialize OpenSearch as the vector database
vector_db = OpenSearchVectorSearch(opensearch_url=opensearch_url,
                            index_name="<YOUR-INDEX-NAME>",
                            embedding_function=oci_cohere_embedding_model,
                            signer=auth_provider,
                            auth_type="RESOURCE_PRINCIPAL",
                            http_auth=auth)

Tâche 6 : ingérer vos données

Utilisez le code Python suivant pour ingérer vos données. 

from langchain.vectorstores import OpenSearchVectorSearch
import oci
from tqdm import tqdm
 
batch_size=100
documents = load_documents() # function defined above feel free to or define a new one to process documents
document_chunks = split_documents(documents) // function defined above feel free to edit
index_name= <YOUR-INDEX-NAME>
 
# Ingest documents in batches
for i in tqdm(range(0, len(document_chunks), batch_size), desc="Ingesting batches"):
    batch = document_chunks[i:i + batch_size]
    vector_db.add_texts(texts=batch,
                     bulk_size=batch_size,
                     embedding=embedding_model,
                     opensearch_url=opensearch_url,
                     index_name= index_name,
                     signer=auth_provider,
                     auth_type=AUTH_TYPE,
                     http_auth=("username", "password"))
 
#refresh index
vector_db.client.indices.refresh(index=index_name)

Tâche 7 : configurer le LLM pour RAG avec LangChain

Les actions rapides d'IA dans OCI Data Science éliminent la complexité du déploiement et de la gestion des LLM. Il fournit une interface sans code pour :

Les actions rapides d'IA sont faciles à utiliser et accessibles via l'environnement de bloc-notes OCI Data Science. Il offre une grande flexibilité. Par exemple, vous pouvez utiliser des ensembles de données stockés dans OCI Object Storage ou votre bloc-notes local pour entraîner, affiner ou évaluer votre modèle. Il s'agit également d'une solution très rentable, car il n'y a pas de frais supplémentaires au-delà des coûts de calcul et de stockage sous-jacents. Plus important encore, vous pouvez accéder à un catalogue de modèles approuvés disponibles dans AI Quick Actions, prêts à être déployés en quelques clics. De plus, vous avez la possibilité d'affiner et d'évaluer l'un de ces modèles sur votre jeu de données personnalisé sans écrire de code. Sans oublier la possibilité d'apporter vos propres artefacts de modèle et de les déployer simplement avec des actions rapides d'IA sans avoir à vous soucier des complexités infra. Enfin, vous pouvez utiliser l'interface d'invite intégrée pour tester et évaluer les performances du modèle déployé.

L'action rapide d'IA est disponible dans votre session de bloc-notes OCI Data Science. Pour utiliser les actions rapides AI, assurez-vous de configurer les stratégies requises dans votre location. Pour plus d'informations, voir Stratégies d'actions rapides AI.

  1. Cliquez sur Actions rapides IA pour lancer des actions rapides IA à partir de votre session de bloc-notes.

    image

  2. Accédez au catalogue de modèles LLM.

    image

  3. Cliquez sur Déploiements et sur Créer un déploiement.

    image

  4. Sur la page Déployer le modèle, entrez les détails requis pour créer un déploiement de modèle.

    image

  5. Une fois le modèle créé, vous pouvez visualiser et tester le modèle déployé.

    image

  6. Créez une évaluation pour le modèle déployé.

    image

Exécutez le code suivant pour utiliser l'intégration LangChain afin d'appeler un modèle de LLM déployé pour répondre aux questions. Dans ce cas, nous allons utiliser le modèle LLM déployé avec AI Quick Actions, en appelant son adresse de prévision comme suit :

import ads
from langchain_community.llms import OCIModelDeploymentLLM

ads.set_auth("resource_principal")
endpoint = "https://modeldeployment.us-ashburn-1.oci.customer-oci.com/ocid1.datasciencemodeldeployment.oc1.iad.am....................../predict"

oads_llm = OCIModelDeploymentLLM(
    endpoint=endpoint,
    model="odsc-llm",
    model_kwargs={"temperature": 0, "max_tokens": 500, 'top_p': 1.0, 'top_k': 1}
)

#test the invoke method to make sure model is deployed and active
oads_llm.invoke("who was the first president of the united states?")

Tâche 8 : effectuer une recherche de conversation et une RAG

Utilisez le code Python suivant pour effectuer une recherche de conversation et RAG.

# Create a retriever from the OpenSearch vector database
retriever = vector_db.as_retriever()

# Load a QA chain that combines the documents and generates an answer
combine_documents_chain = load_qa_chain(oads_llm, chain_type="stuff")

# Create the RetrievalQA chain
qa_chain = RetrievalQA(combine_documents_chain=combine_documents_chain, retriever=retriever)

# Example query
query="What was Notre Dame's first college? be explicit"
response = qa_chain.run(query)
print("Answer:", response)

L'intégralité du code de bout en bout de cette application RAG est disponible ici : Exemple de bloc-notes de service OCI OpenSearch. L'intégralité du référentiel GitHub pour ce tutoriel est disponible ici : opensearch-integration-with-langchain.

Etapes suivantes

L'intégration de LangChain, d'OCI avec OpenSearch, des actions rapides d'IA, d'OCI Generative AI et des blocs-notes offre une solution complète pour la création d'applications de LLM. Que vous développiez des systèmes RAG ou des outils de recherche conversationnelle, ces technologies fonctionnent ensemble pour fournir des solutions puissantes, évolutives et efficaces.

En adoptant cette approche intégrée, les développeurs peuvent libérer tout le potentiel de l'IA générative et fournir des applications transformatrices qui favorisent la réussite de l'entreprise. Commencez dès aujourd'hui à explorer ces outils et faites le premier pas vers la création de l'avenir des applications alimentées par l'IA.

Remerciements

Ressources de formation supplémentaires

Explorez d'autres ateliers sur docs.oracle.com/learn ou accédez à d'autres contenus de formation gratuits sur le canal Oracle Learning YouTube. De plus, visitez le site education.oracle.com/learning-explorer pour devenir un explorateur Oracle Learning.

Pour obtenir la documentation produit, consultez le site Oracle Help Center.