> Discover all available pages from the documentation index: https://mastra.zisheng.pro/fr/llms.txt # Découper les documents et générer leurs embeddings Avant tout traitement, créez une instance de MDocument à partir de votre contenu. Vous pouvez l'initialiser depuis différents formats : ```ts const docFromText = MDocument.fromText('Your plain text content...') const docFromHTML = MDocument.fromHTML('Your HTML content...') const docFromMarkdown = MDocument.fromMarkdown('# Your Markdown content...') const docFromJSON = MDocument.fromJSON(`{ "key": "value" }`) ``` ## Traitement des documents Utilisez `chunk` pour diviser les documents en fragments faciles à traiter. Mastra prend en charge plusieurs stratégies de découpage optimisées pour différents types de documents : - `recursive` : découpage intelligent fondé sur la structure du contenu - `character` : découpage simple basé sur les caractères - `token` : découpage tenant compte des tokens - `markdown` : découpage tenant compte de la structure Markdown - `semantic-markdown` : découpage Markdown fondé sur des familles de titres associées - `html` : découpage tenant compte de la structure HTML - `json` : découpage tenant compte de la structure JSON - `latex` : découpage tenant compte de la structure LaTeX - `sentence` : découpage tenant compte des phrases > **Remarque:** Chaque stratégie accepte des paramètres différents, optimisés pour son mode de découpage. Voici un exemple d'utilisation de la stratégie `recursive` : ```ts const chunks = await doc.chunk({ strategy: 'recursive', maxSize: 512, overlap: 50, separators: ['\n'], extract: { metadata: true, // Optionally extract metadata }, }) ``` Pour les textes dont la structure des phrases doit être préservée, voici un exemple d'utilisation de la stratégie `sentence` : ```ts const chunks = await doc.chunk({ strategy: 'sentence', maxSize: 450, minSize: 50, overlap: 0, sentenceEnders: ['.'], }) ``` Pour les documents Markdown dont il est important de préserver les relations sémantiques entre les sections, voici un exemple d'utilisation de la stratégie `semantic-markdown` : ```ts const chunks = await doc.chunk({ strategy: 'semantic-markdown', joinThreshold: 500, modelName: 'gpt-3.5-turbo', }) ``` > **Remarque:** L'extraction des métadonnées peut faire appel à des LLM ; assurez-vous donc que votre clé d'API est configurée. Les stratégies de découpage sont présentées plus en détail dans notre [documentation de référence de `chunk()`](https://mastra.zisheng.pro/fr/reference/rag/chunk). ## Génération des embeddings Transformez les fragments en embeddings avec le fournisseur de votre choix. Mastra prend en charge les modèles d'embedding par l'intermédiaire du Model Router. ### Utiliser le Model Router La méthode la plus simple consiste à utiliser le Model Router de Mastra avec des chaînes `provider/model` : ```ts import { ModelRouterEmbeddingModel } from '@mastra/core/llm' import { embedMany } from 'ai' const { embeddings } = await embedMany({ model: new ModelRouterEmbeddingModel('openai/text-embedding-3-small'), values: chunks.map(chunk => chunk.text), }) ``` Mastra prend en charge les modèles d'embedding d'OpenAI et de Google. Pour obtenir la liste complète des modèles pris en charge, consultez la [référence des embeddings](https://mastra.zisheng.pro/fr/reference/rag/embeddings). Le Model Router détecte automatiquement les clés d'API dans les variables d'environnement. Les fonctions d'embedding renvoient des vecteurs, c'est-à-dire des tableaux de nombres qui représentent le sens sémantique de votre texte et qui peuvent être utilisés directement pour effectuer des recherches par similarité dans votre base de données vectorielle. ### Configurer les dimensions des embeddings Les modèles d'embedding produisent généralement des vecteurs comportant un nombre fixe de dimensions (par exemple, 1 536 pour le modèle `text-embedding-3-small` d'OpenAI). Certains modèles permettent de réduire cette dimensionnalité, ce qui peut contribuer à : - Diminuer les besoins de stockage dans les bases de données vectorielles - Réduire les coûts de calcul des recherches par similarité Voici quelques modèles compatibles : OpenAI (modèles text-embedding-3) : ```ts import { ModelRouterEmbeddingModel } from '@mastra/core/llm' const { embeddings } = await embedMany({ model: new ModelRouterEmbeddingModel('openai/text-embedding-3-small'), options: { dimensions: 256, // Only supported in text-embedding-3 and later }, values: chunks.map(chunk => chunk.text), }) ``` Google (text-embedding-001) : ```ts const { embeddings } = await embedMany({ model: google('gemini-embedding-001', { outputDimensionality: 256, // Truncates excessive values from the end }), values: chunks.map(chunk => chunk.text), }) ``` > **Compatibilité avec les bases de données vectorielles:** Lorsque vous stockez des embeddings, l'index de la base de données vectorielle doit être configuré de façon à correspondre à la taille de sortie de votre modèle d'embedding. Si les dimensions ne correspondent pas, des erreurs ou une corruption des données peuvent se produire. ## Exemple : pipeline complet Voici un exemple illustrant le traitement d'un document et la génération d'embeddings avec les deux fournisseurs : ```ts import { embedMany } from 'ai' import { MDocument } from '@mastra/rag' // Initialize document const doc = MDocument.fromText(` Climate change poses significant challenges to global agriculture. Rising temperatures and changing precipitation patterns affect crop yields. `) // Create chunks const chunks = await doc.chunk({ strategy: 'recursive', maxSize: 256, overlap: 50, }) // Generate embeddings with OpenAI import { ModelRouterEmbeddingModel } from '@mastra/core/llm' const { embeddings } = await embedMany({ model: new ModelRouterEmbeddingModel('openai/text-embedding-3-small'), values: chunks.map(chunk => chunk.text), }) // OR // Generate embeddings with Cohere const { embeddings } = await embedMany({ model: 'cohere/embed-english-v3.0', values: chunks.map(chunk => chunk.text), }) // Store embeddings in your vector database await vectorStore.upsert({ indexName: 'embeddings', vectors: embeddings, }) ``` Pour consulter d'autres exemples de stratégies de découpage et de configurations d'embedding, reportez-vous aux pages suivantes : - [Référence du découpage](https://mastra.zisheng.pro/fr/reference/rag/chunk) - [Référence des embeddings](https://mastra.zisheng.pro/fr/reference/rag/embeddings) Pour en savoir plus sur les bases de données vectorielles et les embeddings, consultez : - [Bases de données vectorielles](https://mastra.zisheng.pro/fr/guides/rag/vector-databases) - [Référence de l'API d'embedding](https://mastra.zisheng.pro/fr/reference/rag/embeddings)