Maison > développement back-end > Tutoriel Python > Création d'une liste de tâches contextuelle avec les API Nestjs, RAG, Prisma et Gemini

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

Patricia Arquette
Libérer: 2025-01-27 18:11:09
original
375 Les gens l'ont consulté

Building a Context-Aware To-Do List with Nestjs, RAG, Prisma, and Gemini API

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 :
nest new todo-app
cd todo-app
Copier après la connexion
  1. Supprimez les fichiers par défaut inutiles :
rm src/app.controller.* src/app.service.* src/app.module.ts
Copier après la connexion

Étape 2 : Installer les dépendances

Installer les dépendances requises :

npm install prisma @prisma/client @google/generative-ai dotenv
Copier après la connexion

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

  1. Initialiser Prisma :
npx prisma init
Copier après la connexion
  1. 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>
Copier après la connexion
  1. Activez PgVector dans votre fichier schema.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)")
}
Copier après la connexion
  1. Appliquer la migration de la base de données :
npx prisma migrate dev --name init
Copier après la connexion

Étape 4 : Configurer Prisma dans NestJS

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

// 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();
  }
}
Copier après la connexion

Importez PrismaModule dans votre module principal :

// 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 {}
Copier après la connexion

Étape 5 : Configurer le module Tâches

  1. Module Générer des tâches :
nest generate module tasks
nest generate service tasks
nest generate controller tasks
Copier après la connexion
  1. Implémenter le service de tâches :
// 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};
    `;
  }
}
Copier après la connexion
  1. Implémenter TasksController :
// 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();
  }
}
Copier après la connexion

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

  1. Créer un GeminiService :
// 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;
  }
}
Copier après la connexion

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!

Déclaration de ce site Web
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
Derniers articles par auteur
Tutoriels populaires
Plus>
Derniers téléchargements
Plus>
effets Web
Code source du site Web
Matériel du site Web
Modèle frontal