Créer une application Python simple pour augmenter la productivité à l'aide de l'IA et de l'API BotHub

Vous avez déjà quitté une réunion en ligne importante avec des tâches assignées et des idées discutées, mais vous ne vous souvenez plus vraiment de qui a dit quoi ? On a presque l'impression que vous avez besoin d'un preneur de notes dédié pour suivre tout et générer des rapports. Une meilleure solution consiste à automatiser cela avec un script, ce qui est exactement ce que nous allons faire.

Dans ce tutoriel, je vais vous montrer comment créer une application qui analyse automatiquement les réunions et génère des rapports à l'aide de l'API BotHub (Whisper-1 Claude 3.5 Sonnet). Cette application transcrira les enregistrements audio, identifiera les informations clés (qui a dit quoi et quelles tâches ont été discutées) et compilera un rapport, y compris une version PDF.

Configuration des dépendances et de la configuration du projet

Avant de commencer, assurons-nous que tous les composants nécessaires sont installés, y compris Python et les bibliothèques requises pour travailler avec l'API et les fichiers audio. Nous installerons les éléments suivants :

• os et pathlib.Path : pour travailler avec des variables d'environnement et des chemins de fichiers ;
• dotenv : pour charger des données sensibles à partir d'un fichier .env ;
• fpdf : pour générer des fichiers PDF ;
• openai : pour interagir avec l'API BotHub.

Installez ces packages en utilisant pip :

pip install openai python-dotenv fpdf

Nous utiliserons également la journalisation pour suivre l'exécution du programme et enregistrer toute erreur ou message important. Nous allons mettre en place une journalisation de base au niveau INFO :

import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

Pour interagir avec l'API BotHub, vous devez d'abord vous inscrire sur la plateforme BotHub et obtenir une clé API. Cette clé est utilisée pour authentifier les demandes que nous enverrons.

Pour un stockage sécurisé des clés, créez un fichier .env dans le répertoire racine de votre projet et ajoutez votre clé API générée :

BOTHUB_API_KEY=votre_api_key

Ensuite, utilisez la fonction load_dotenv() de la bibliothèque dotenv pour charger les données du fichier .env, les rendant accessibles à notre code :

from dotenv import load_dotenv

load_dotenv()

Pour travailler avec l'API BotHub, créez une instance OpenAI, en fournissant l'api_key et la base_url pour le service BotHub. La clé API est chargée depuis l'environnement à l'aide de os.getenv('BOTHUB_API_KEY'):

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv('BOTHUB_API_KEY'),
    base_url='https://bothub.chat/api/v2/openai/v1'
)

Fonction de base pour le traitement audio

Cette étape consiste à créer une fonction qui transcrit un fichier audio en texte. Nous utiliserons l'API BotHub et Whisper-1 pour la reconnaissance vocale. Le fichier audio est ouvert en mode lecture binaire (rb), puis nous utilisons la méthode client.audio.transcriptions.create pour envoyer le fichier audio au serveur pour traitement. La réponse contient la transcription du texte. Si la transcription réussit, un message « Transcription terminée » est enregistré et le texte est renvoyé pour un traitement ultérieur. En cas d'erreur, le message d'erreur est enregistré.

def transcribe_audio(audio_file_path):
    try:
        with open(audio_file_path, "rb") as audio_file:
            transcript = client.audio.transcriptions.create(
                model="whisper-1",
                file=audio_file
            )
        logger.info("Transcription complete.")
        return transcript.text
    except Exception as e:
        logger.error(f"Error during audio transcription: {e}")
        return None

Extracting Key Insights

After transcription, we have the text of our meeting. Now, our goal is to extract key insights, such as discussed tasks, decisions made, and any identified problems. Using client.chat.completions.create, we create a request to extract these key points, specifying the model, the meeting text, and the request in a messages format, where we instruct the model to identify the main tasks and problems. The function returns a string containing the key insights upon successful execution.

def extract_key_points(meeting_text):
    try:
        response = client.chat.completions.create(
            model="claude-3.5-sonnet",
            messages=[
                {
                    "role": "user",
                    "content": f"Analyze the following meeting transcript and extract key insights, such as tasks, decisions, and discussed problems:\n\n{meeting_text}"
                }
            ]
        )
        logger.info("Key insight extraction complete.")
        return response.choices[0].message.content
    except Exception as e:
        logger.error(f"Error extracting key insights: {e}")
        return None

Sentiment Analysis

We can also analyze the sentiment of the meeting text. Similar to extract_key_points, we use client.chat.completions.create to request a sentiment analysis of the provided text. The function returns the sentiment analysis result or an error message.

def analyze_sentiment(meeting_text):
    try:
        response = client.chat.completions.create(
            model="claude-3.5-sonnet",
            messages=[
                {
                    "role": "user",
                    "content": f"Analyze the sentiment of the following text:\n\n{meeting_text}"
                }
            ]
        )
        logger.info("Sentiment analysis complete.")
        return response.choices[0].message.content
    except Exception as e:
        logger.error(f"Error during sentiment analysis: {e}")
        return None

Report Generation

Once the key insights and sentiment analysis are complete, we need to compile them into a report. This report should be logical, coherent, and concise. We use client.chat.completions.create, providing a request with the key points and sentiment analysis, allowing the API to generate the final report text. The function returns the report text upon successful completion.

def generate_report(key_points, sentiment):
    try:
        content = f"Compile a meeting report considering the following key points and sentiment analysis:\n\nKey Points:\n{key_points}\n\nSentiment:\n{sentiment}"
        report = client.chat.completions.create(
            model="claude-3.5-sonnet",
            messages=[
                {
                    "role": "user",
                    "content": content
                }
            ]
        )
        logger.info("Report generation complete.")
        return report.choices[0].message.content
    except Exception as e:
        logger.error(f"Error generating report: {e}")
        return None

To facilitate easy storage and sharing, we save the report as a PDF. We use the FPDF library for PDF creation. We add a page, enable automatic text wrapping with multi_cell. After creating and populating the page with the report text, we save the report using output(file_path).

from fpdf import FPDF

def save_report_as_pdf(report_text, file_path="meeting_report.pdf"):
    pdf = FPDF()
    pdf.add_page()
    pdf.set_auto_page_break(auto=True, margin=15)
    pdf.output(file_path)
    logger.info(f"Report saved as {file_path}")

Main Function

This function orchestrates all the previous steps. It begins by transcribing the audio. If transcription fails, an error message is displayed, and the function terminates. Next, it calls the function to extract key insights. If an error occurs, it returns an appropriate message. Sentiment analysis is performed similarly, and if successful, the report text is generated. If all steps complete successfully, save_report_as_pdf is called to save the report in PDF format. Finally, the function returns the generated report text.

def analyze_meeting(audio_file_path):
    meeting_text = transcribe_audio(audio_file_path)
    if not meeting_text:
        return "Error during audio transcription."

    key_points = extract_key_points(meeting_text)
    if not key_points:
        return "Error extracting key insights."

    sentiment = analyze_sentiment(meeting_text)
    if not sentiment:
        return "Error during sentiment analysis."

    report_text = generate_report(key_points, sentiment) # Pass sentiment to report generation
    if not report_text:
        return "Error generating report."

    save_report_as_pdf(report_text)
    return report_text

---

In conclusion, we've built a small application that can boost your productivity and help you manage your time more effectively. We implemented a series of core functions, including audio transcription, key insight extraction, report generation, and saving the report in PDF format. This tool will help you keep track of important ideas and tasks, saving you time and effort.

Hope this helped! If so, any support is welcome, thanks for reading! ?

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!