Créez un agent de messagerie alimenté par l'IA avec du code réutilisable

Pourquoi automatiser vos tâches ?

Salut à tous ?! En tant que développeur d'applications, je suis ravi de partager comment vous pouvez créer des agents simples mais puissants pour automatiser vos tâches quotidiennes.

? Comme beaucoup d’entre vous, je reçois chaque jour un nombre impressionnant d’e-mails. Malgré tous mes efforts, atteindre l’insaisissable Inbox Zero reste un défi. Trier les e-mails tels que les confirmations de commande et les mises à jour d’expédition est fastidieux et prend du temps.

Mais voici la bonne nouvelle : l'automatisation peut sauver la situation !

? J'ai écrit un script de base tirant parti de l'IA pour aider à automatiser la catégorisation des e-mails, et vous le pouvez aussi.

Dans cet article, je partagerai des extraits de code réutilisables pour vous aider à créer vos propres agents d'automatisation adaptés à vos besoins. ?

---

La beauté de l'automatisation

Il existe d'innombrables outils, y compris des plateformes sans code, qui peuvent gérer des processus entiers pour vous. Cependant, je préfère diviser les tâches en extraits de code modulaires. Pourquoi?

1. Flexibilité : le code modulaire peut facilement s'adapter aux exigences changeantes.
2. Réutilisabilité : Écrivez une fois, utilisez pour toujours.
3. Maintenabilité : les petits morceaux de code indépendants sont plus faciles à déboguer et à améliorer.

En adoptant une approche incrémentale, vous pouvez progressivement remplacer les étapes manuelles par des étapes automatisées.

?‍? Mon outil de prédilection pour le prototypage de scripts est Znote, un bloc-notes avec codage en direct et IA qui m'aide à suivre et à améliorer mes flux de travail. Essayez-le ou utilisez votre IDE préféré !

---

Créons un agent d'automatisation des e-mails

Objectifs

Lorsqu'un nouvel e-mail arrive, nous souhaitons :

1. Lisez l'e-mail et extrayez les informations pertinentes.
2. Utiliser un LLM pour déterminer sa catégorie à partir d'une liste prédéfinie.
3. Créez des étiquettes Gmail (si elles n'existent pas déjà).
4. Mettez à jour les étiquettes de l'e-mail pour refléter la catégorie attribuée.

---

Commencer

Conditions préalables

Étape 1 : Activer l'API Gmail

1. Accédez à Google Cloud Console et activez l'API Gmail.
2. Configurez les informations d'identification OAuth pour une application de bureau. Suivez ces étapes pour télécharger votre fichier google-credentials.json et placez-le dans le répertoire de votre projet.

Étape 2 : Installer Ollama

Téléchargez Ollama pour lancer un LLM local. Une fois installé, téléchargez un modèle :

ollama pull mistral  

Étape 3 : Installer les dépendances

Installez les bibliothèques Node.js requises :

ollama pull mistral  

---

Écrire le code

1. Authentifiez-vous avec l'API Google

Configurer une connexion OAuth à Gmail :

npm install -S @google-cloud/local-auth googleapis openai  

2. Créez des étiquettes Gmail

Utilisez cette fonction pour créer des étiquettes et récupérer leurs identifiants :

// google-api.js
const fs = require("fs");
const path = require("path");
const { authenticate } = require("@google-cloud/local-auth");
const { google } = require("googleapis");

class GoogleAPI {
  constructor(credentialFilename) {
    this.TOKEN_PATH = path.join(__dirname, `token-${credentialFilename}`);
    this.CREDENTIALS_PATH = path.join(__dirname, credentialFilename);
    this.SCOPES = [
      "https://mail.google.com/",
      "https://www.googleapis.com/auth/gmail.modify",
    ];
  }

  async authorize() {
    const loadSavedCredentials = () => {
      try {
        const content = fs.readFileSync(this.TOKEN_PATH);
        return google.auth.fromJSON(JSON.parse(content));
      } catch {
        return null;
      }
    };

    const saveCredentials = (client) => {
      const keys = JSON.parse(fs.readFileSync(this.CREDENTIALS_PATH));
      fs.writeFileSync(
        this.TOKEN_PATH,
        JSON.stringify({
          type: "authorized_user",
          client_id: keys.installed.client_id,
          client_secret: keys.installed.client_secret,
          refresh_token: client.credentials.refresh_token,
        })
      );
    };

    let client = await loadSavedCredentials();
    if (!client) {
      client = await authenticate({
        scopes: this.SCOPES,
        keyfilePath: this.CREDENTIALS_PATH,
      });
      if (client.credentials) saveCredentials(client);
    }
    return client;
  }
}

module.exports = GoogleAPI;

3. Lire les e-mails

Extraire les détails de l'API du message :

async function createAndGetLabels(labelsToCreate) {
  const google = await getGoogleClient();
  const gmail = google.gmail({ version: "v1" });

  const existingLabels = (await gmail.users.labels.list({ userId: "me" })).data.labels || [];

  const labelsMap = new Map();
  for (const label of labelsToCreate) {
    const existing = existingLabels.find((l) => l.name === label);
    if (existing) {
      labelsMap.set(label, existing.id);
    } else {
      const res = await gmail.users.labels.create({
        userId: "me",
        requestBody: { name: label },
      });
      labelsMap.set(label, res.data.id);
    }
  }
  return labelsMap;
}

4. Décrypter les informations pertinentes

Extraire des détails significatifs des e-mails :

async function readEmails(gmail, maxResults = 10) {
  const res = await gmail.users.messages.list({ userId: "me", labelIds: ["INBOX"], maxResults });
  return Promise.all(
    res.data.messages.map(async ({ id }) => {
      const email = await gmail.users.messages.get({ userId: "me", id });
      return email.data;
    })
  );
}

5. Utilisez un LLM pour la catégorisation

Intégrez Ollama ou OpenAI pour classer les emails :

function extractMailInfos(mail) {
  // Define the headers to extract
  const relevantHeaders = ["Date", "Subject"];

  // Extract and structure the relevant headers
  const headers = mail.payload.headers
    .filter(header => relevantHeaders.includes(header.name))
    .reduce((accumulator, header) => {
      accumulator[header.name] = header.value;
      return accumulator;
    }, {});

  // Add the unique mail ID directly to the headers object
  headers.id = mail.id;

  return headers;
}

---

Mettre tout cela ensemble

Voici comment tout fonctionne ensemble :

async function classifyEmail(prompt) {
  const { OpenAI } = require("openai");
  const openai = new OpenAI({ baseURL: "http://127.0.0.1:11434/v1", apiKey: "not-needed" });

  const response = await openai.chat.completions.create({
    model: "mistral",
    temperature: 0.3,
    messages: [{ role: "user", content: prompt }],
  });

  return response.choices[0].message.content.trim();
}

---

? C'est ça! Votre boîte de réception est désormais plus intelligente et mieux organisée.

Aller plus loin

Mais pourquoi s'arrêter là ? Explorez des exemples plus avancés pour lire le contenu des e-mails, envoyer des brouillons et créer tout ce dont vous avez besoin pour des réponses entièrement automatisées.
Pour plus d'idées d'automatisation et de scripts réutilisables, consultez Znote.

Transformons vos tâches quotidiennes en quelque chose d'amusant et d'efficace ! ?

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!