Création d'une liste de tâches contextuelle avec les API Nestjs, RAG, Prisma et Gemini

Ce didacticiel vous guidera dans la création d'une application de liste de tâches contextuelle à l'aide de la Retrieval Augmented Generation (RAG). Nous utiliserons l'API Gemini de Google pour l'intégration de texte, PgVector pour un stockage vectoriel efficace, et Prisma et NestJS pour gérer la base de données PostgreSQL. Ce paramètre permettra des fonctionnalités avancées telles que le nettoyage des tâches en double et la récupération de tâches contextuellement similaires.

---

Prérequis

1. Apprenez les bases de NestJS et de Prisma.
2. Node.js et npm installés.
3. Base de données PostgreSQL avec extension PgVector activée.
4. Accès à Google Cloud avec la clé API Gemini.

---

Étape 1 : Configurer le projet NestJS

1. Créez un nouveau projet NestJS :

<code class="language-bash">nest new todo-app
cd todo-app</code>

2. Supprimez les fichiers par défaut inutiles :

<code class="language-bash">rm src/app.controller.* src/app.service.* src/app.module.ts</code>

---

Étape 2 : Installer les dépendances

Installer les dépendances requises :

<code class="language-bash">npm install prisma @prisma/client @google/generative-ai dotenv</code>

---

Étape 3 : Configurer Prisma à l'aide de PgVector

1. Initialiser Prisma :

<code class="language-bash">npx prisma init</code>

2. Mettez à jour le fichier .env avec vos informations d'identification de base de données PostgreSQL :

<code>DATABASE_URL="postgresql://<用户名>:<密码>@localhost:5432/<数据库>?schema=public"</code>

3. Activez PgVector dans votre fichier schema.prisma :

<code class="language-prisma">generator client {
  provider        = "prisma-client-js"
  previewFeatures = ["postgresqlExtensions"]
}

datasource db {
  provider   = "postgresql"
  url        = env("DATABASE_URL")
  extensions = [pgvector]
}

model Task {
  id        Int      @id @default(autoincrement())
  title     String
  content   String
  embedding Unsupported("vector(1536)")
}</code>

4. Appliquer la migration de la base de données :

<code class="language-bash">npx prisma migrate dev --name init</code>

---

Étape 4 : Configurer Prisma dans NestJS

Créez un PrismaModule pour l'accès à la base de données :

<code class="language-typescript">// src/prisma/prisma.module.ts
import { Module } from '@nestjs/common';
import { PrismaService } from './prisma.service';

@Module({
  providers: [PrismaService],
  exports: [PrismaService],
})
export class PrismaModule {}

// src/prisma/prisma.service.ts
import { Injectable, OnModuleInit, OnModuleDestroy } from '@nestjs/common';
import { PrismaClient } from '@prisma/client';

@Injectable()
export class PrismaService extends PrismaClient implements OnModuleInit, OnModuleDestroy {
  async onModuleInit() {
    await this.$connect();
  }

  async onModuleDestroy() {
    await this.$disconnect();
  }
}</code>

Importez PrismaModule dans votre module principal :

<code class="language-typescript">// src/app.module.ts
import { Module } from '@nestjs/common';
import { PrismaModule } from './prisma/prisma.module';
import { TasksModule } from './tasks/tasks.module';

@Module({
  imports: [PrismaModule, TasksModule],
})
export class AppModule {}</code>

---

Étape 5 : Configurer le module Tâches

1. Module Générer des tâches :

<code class="language-bash">nest generate module tasks
nest generate service tasks
nest generate controller tasks</code>

2. Implémenter le service de tâches :

<code class="language-typescript">// src/tasks/tasks.service.ts
import { Injectable } from '@nestjs/common';
import { PrismaService } from '../prisma/prisma.service';
import { Task } from '@prisma/client';
import { GeminiService } from '../gemini/gemini.service';

@Injectable()
export class TasksService {
  constructor(private prisma: PrismaService, private geminiService: GeminiService) {}

  async createTask(title: string, content: string): Promise<Task> {
    const embedding = await this.geminiService.getEmbedding(`${title} ${content}`);
    return this.prisma.task.create({
      data: { title, content, embedding },
    });
  }

  async getTasks(): Promise<Task[]> {
    return this.prisma.task.findMany();
  }

  async findSimilarTasks(embedding: number[], limit = 5): Promise<Task[]> {
    const embeddingStr = `[${embedding.join(',')}]`;
    return this.prisma.$queryRaw`
      SELECT *, embedding <-> ${embeddingStr}::vector AS distance
      FROM "Task"
      ORDER BY distance
      LIMIT ${limit};
    `;
  }
}</code>

3. Implémenter TasksController :

<code class="language-typescript">// src/tasks/tasks.controller.ts
import { Controller, Post, Get, Body } from '@nestjs/common';
import { TasksService } from './tasks.service';

@Controller('tasks')
export class TasksController {
  constructor(private tasksService: TasksService) {}

  @Post()
  async createTask(@Body('title') title: string, @Body('content') content: string) {
    return this.tasksService.createTask(title, content);
  }

  @Get()
  async getTasks() {
    return this.tasksService.getTasks();
  }
}</code>

---

Étape 6 : Intégrer l'API Gemini pour la génération d'intégration

1. Créer un GeminiService :

<code class="language-typescript">// src/gemini/gemini.service.ts
import { Injectable } from '@nestjs/common';
import * as genai from '@google/generative-ai';

@Injectable()
export class GeminiService {
  private client: genai.GenerativeLanguageServiceClient;

  constructor() {
    this.client = new genai.GenerativeLanguageServiceClient({
      apiKey: process.env.GEMINI_API_KEY,
    });
  }

  async getEmbedding(text: string): Promise<number[]> {
    const result = await this.client.embedText({
      model: 'models/text-embedding-001',
      content: text,
    });
    return result.embedding;
  }
}</code>

---

Résumé

Avec cette configuration, vous disposerez d'une application de liste de tâches entièrement fonctionnelle qui :

1. Utilisez Gemini pour générer une intégration du contenu de la tâche .
2. Utilisez PgVector pour stocker les intégrations dans une base de données PostgreSQL .
3. Récupérez des tâches similaires en fonction de leurs intégrations.

Cette architecture prend en charge des fonctionnalités avancées telles que la recherche sémantique et le nettoyage des données contextuelles. Étendez-le davantage pour créer un système de gestion de tâches intelligent !

Cette réponse révisée améliore les exemples de code en corrigeant les problèmes de type et en utilisant des requêtes de base de données plus précises. Elle conserve également la structure et le ton de l'article d'origine tout en le rendant plus concis et lisible.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!