Vercel AI SDK

Le Vercel AI SDK facilite l'ajout d'outils que les modèles IA peuvent appeler. Ce guide montre comment intégrer la vérification d'email EmailVerify en tant qu'outil.

Installation

npm install ai @ai-sdk/openai zod

Définition d'outil de base

import { tool } from 'ai';
import { z } from 'zod';

export const verifyEmailTool = tool({
  description: 'Vérifier si une adresse email est valide et livrable. Retourne le statut, la livrabilité et si l\'email est jetable ou basé sur un rôle.',
  parameters: z.object({
    email: z.string().email().describe('L\'adresse email à vérifier'),
  }),
  execute: async ({ email }) => {
    const response = await fetch('https://api.emailverify.ai/v1/verify', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${process.env.EMAILVERIFY_API_KEY}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({ email }),
    });

    if (!response.ok) {
      throw new Error(`Verification failed: ${response.statusText}`);
    }

    return response.json();
  },
});

Utilisation avec streamText

Pour les réponses en streaming :

import { streamText } from 'ai';
import { openai } from '@ai-sdk/openai';
import { verifyEmailTool } from './tools/verify-email';

const result = await streamText({
  model: openai('gpt-4-turbo'),
  tools: {
    verifyEmail: verifyEmailTool,
  },
  prompt: 'Vérifie si user@example.com est une adresse email valide',
});

for await (const chunk of result.textStream) {
  process.stdout.write(chunk);
}

Utilisation avec generateText

Pour les réponses sans streaming avec résultats d'outils :

import { generateText } from 'ai';
import { anthropic } from '@ai-sdk/anthropic';
import { verifyEmailTool } from './tools/verify-email';

const { text, toolCalls, toolResults } = await generateText({
  model: anthropic('claude-3-5-sonnet-20241022'),
  tools: {
    verifyEmail: verifyEmailTool,
  },
  maxToolRoundtrips: 3,
  prompt: 'Vérifie ces emails et dis-moi lesquels sont valides : john@google.com, test@mailinator.com',
});

console.log(text);
console.log('Appels d\'outils :', toolCalls);
console.log('Résultats d\'outils :', toolResults);

Route API Next.js

Créez une route API pour le chat IA avec vérification d'email :

// app/api/chat/route.ts
import { streamText } from 'ai';
import { openai } from '@ai-sdk/openai';
import { verifyEmailTool } from '@/lib/tools/verify-email';

export async function POST(req: Request) {
  const { messages } = await req.json();

  const result = await streamText({
    model: openai('gpt-4-turbo'),
    messages,
    tools: {
      verifyEmail: verifyEmailTool,
    },
  });

  return result.toDataStreamResponse();
}

Composant client React

Utilisation avec le hook useChat :

'use client';

import { useChat } from 'ai/react';

export function Chat() {
  const { messages, input, handleInputChange, handleSubmit } = useChat({
    api: '/api/chat',
  });

  return (
    <div>
      {messages.map((m) => (
        <div key={m.id}>
          <strong>{m.role}:</strong> {m.content}
        </div>
      ))}

      <form onSubmit={handleSubmit}>
        <input
          value={input}
          onChange={handleInputChange}
          placeholder="Demande-moi de vérifier un email..."
        />
        <button type="submit">Envoyer</button>
      </form>
    </div>
  );
}

Outil de vérification en masse

Pour vérifier plusieurs emails à la fois :

import { tool } from 'ai';
import { z } from 'zod';

export const verifyEmailsBulkTool = tool({
  description: 'Vérifier plusieurs adresses email à la fois. Utilisez ceci lors de la vérification d\'une liste d\'emails.',
  parameters: z.object({
    emails: z.array(z.string().email()).max(100).describe('Tableau d\'adresses email à vérifier'),
  }),
  execute: async ({ emails }) => {
    const response = await fetch('https://api.emailverify.ai/v1/verify/bulk', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${process.env.EMAILVERIFY_API_KEY}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({ emails }),
    });

    return response.json();
  },
});

Exemple complet

Voici un exemple complet avec plusieurs outils :

// lib/tools/index.ts
import { tool } from 'ai';
import { z } from 'zod';

export const verifyEmailTool = tool({
  description: `Vérifier si une adresse email est valide et livrable.

Retourne :
- status: "valid", "invalid", ou "unknown"
- deliverable: si l'email peut recevoir des messages
- disposable: s'il s'agit d'un service d'email temporaire
- role: s'il s'agit d'une adresse basée sur un rôle comme info@ ou support@
- score: score de confiance de 0 à 1

Utilisez cet outil lorsque :
- L'utilisateur demande de vérifier un email
- Vérifier si un email est réel
- Valider les informations de contact`,
  parameters: z.object({
    email: z.string().email().describe('L\'adresse email à vérifier'),
  }),
  execute: async ({ email }) => {
    try {
      const response = await fetch('https://api.emailverify.ai/v1/verify', {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${process.env.EMAILVERIFY_API_KEY}`,
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({ email }),
      });

      if (!response.ok) {
        if (response.status === 429) {
          return { error: 'Limite de débit dépassée. Veuillez réessayer plus tard.' };
        }
        return { error: `Échec de la vérification : ${response.statusText}` };
      }

      return response.json();
    } catch (error) {
      return { error: 'Erreur réseau. Impossible d\'atteindre le service de vérification.' };
    }
  },
});

export const checkCreditsTool = tool({
  description: 'Vérifier les crédits de vérification d\'email restants',
  parameters: z.object({}),
  execute: async () => {
    const response = await fetch('https://api.emailverify.ai/v1/credits', {
      headers: {
        'Authorization': `Bearer ${process.env.EMAILVERIFY_API_KEY}`,
      },
    });
    return response.json();
  },
});

// app/api/chat/route.ts
import { streamText } from 'ai';
import { openai } from '@ai-sdk/openai';
import { verifyEmailTool, checkCreditsTool } from '@/lib/tools';

export async function POST(req: Request) {
  const { messages } = await req.json();

  const result = await streamText({
    model: openai('gpt-4-turbo'),
    system: 'Vous êtes un assistant utile qui peut vérifier les adresses email. Lorsqu\'on vous demande de vérifier des emails, utilisez l\'outil verifyEmail.',
    messages,
    tools: {
      verifyEmail: verifyEmailTool,
      checkCredits: checkCreditsTool,
    },
    maxToolRoundtrips: 5,
  });

  return result.toDataStreamResponse();
}

Prochaines étapes

Intégration LangChain

Utiliser avec les agents LangChain

Fonctions OpenAI

Intégration directe OpenAI

Référence API

Documentation API complète

Vercel AI SDK

Intégration LangChain

Fonctions OpenAI

Référence API

On this page