> Discover all available pages from the documentation index: https://mastra.zisheng.pro/fr/llms.txt

# Stockage libSQL

[libSQL](https://docs.turso.tech/libsql) est une base de données open source compatible avec SQLite qui prend en charge les déploiements locaux et distants. Elle permet de stocker l’historique des messages, les instantanés de Workflow, les traces et les scores d’Evals.

Pour les vecteurs utilisés par le rappel sémantique ou le RAG traditionnel, utilisez [libSQL Vector](https://mastra.zisheng.pro/fr/reference/vectors/libsql), qui prend en charge les embeddings et la recherche vectorielle.

## Installation

Les fournisseurs de Storage doivent être installés sous forme de packages distincts :

**npm**:

```bash
npm install @mastra/libsql@latest
```

**pnpm**:

```bash
pnpm add @mastra/libsql@latest
```

**Yarn**:

```bash
yarn add @mastra/libsql@latest
```

**Bun**:

```bash
bun add @mastra/libsql@latest
```

## Utilisation

```typescript
import { LibSQLStore } from '@mastra/libsql'
import { Mastra } from '@mastra/core'

const mastra = new Mastra({
  storage: new LibSQLStore({
    id: 'libsql-storage',
    url: 'file:./storage.db',
  }),
})
```

Stockage de fichiers au niveau de l’Agent :

```typescript
import { Memory } from '@mastra/memory'
import { Agent } from '@mastra/core/agent'
import { LibSQLStore } from '@mastra/libsql'

export const agent = new Agent({
  id: 'example-agent',
  memory: new Memory({
    storage: new LibSQLStore({
      id: 'libsql-storage',
      url: 'file:./agent.db',
    }),
  }),
})
```

> **Attention:** Le stockage de fichiers ne fonctionne pas avec les plateformes serverless dont le système de fichiers est éphémère. Pour les déploiements serverless, utilisez [Turso](https://turso.tech) ou un autre moteur de base de données.

Production avec une base de données distante :

```typescript
storage: new LibSQLStore({
  id: 'libsql-storage',
  url: 'libsql://your-db-name.aws-ap-northeast-1.turso.io',
  authToken: process.env.TURSO_AUTH_TOKEN,
})
```

Pour le développement local et les tests, vous pouvez stocker les données en mémoire :

```typescript
storage: new LibSQLStore({
  id: 'libsql-storage',
  url: ':memory:',
})
```

> **Attention:** Le stockage en mémoire est réinitialisé lorsque le processus change. Il convient uniquement au développement.

## Options

**url** (`string`): URL de la base de données. Utilisez :memory: pour une base de données en mémoire, file:filename.db pour une base de données dans un fichier, ou une chaîne de connexion libSQL (par exemple, libsql://your-database.turso.io) pour un stockage distant.

**authToken** (`string`): Token d’authentification des bases de données libSQL distantes.

## Tables gérées

L’implémentation du stockage crée automatiquement les tables de stockage principales, notamment `mastra_notifications` pour les enregistrements de la boîte de réception de notifications et les métadonnées de distribution.

`LibSQLStore` expose le stockage des notifications au moyen de `getStore('notifications')`.

## Initialisation

Lorsque vous transmettez un Storage à la classe Mastra, `init()` est appelée automatiquement afin de créer le [schéma principal](https://mastra.zisheng.pro/fr/reference/storage/overview) :

```typescript
import { Mastra } from '@mastra/core'
import { LibSQLStore } from '@mastra/libsql'

const storage = new LibSQLStore({
  id: 'libsql-storage',
  url: 'file:./storage.db',
})

const mastra = new Mastra({
  storage, // init() called automatically
})
```

Si vous utilisez directement le Storage sans Mastra, appelez explicitement `init()` :

```typescript
import { LibSQLStore } from '@mastra/libsql'

const storage = new LibSQLStore({
  id: 'libsql-storage',
  url: 'file:./storage.db',
})

await storage.init()

// Access domain-specific stores via getStore()
const memoryStore = await storage.getStore('memory')
const thread = await memoryStore?.getThreadById({ threadId: '...' })
```

## Observability

libSQL prend en charge l’Observability et convient parfaitement au développement local. Utilisez la [stratégie de traçage](https://mastra.zisheng.pro/fr/docs/observability/integrations/exporters/mastra-storage) `realtime` pour obtenir une visibilité immédiate pendant le débogage.

Pour les environnements de production dont le volume de traces est plus élevé, envisagez d’utiliser [PostgreSQL](https://mastra.zisheng.pro/fr/reference/storage/postgresql) ou [ClickHouse avec un Storage composite](https://mastra.zisheng.pro/fr/reference/storage/composite).