aiyou

package module
v1.2.3 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Feb 9, 2025 License: GPL-3.0 Imports: 4 Imported by: 0

README

aiyou.golib - Bibliothèque Go pour l'API AI.YOU

aiyou.golib est une bibliothèque cliente Go conçue pour interagir avec l'API d'AI.YOU, une plateforme d'intelligence artificielle.

Fonctionnalités

  • Chat Completion : Génération de texte en mode conversationnel, avec support du streaming.
  • Transcription Audio : Transcription de fichiers audio (WAV, MP3, M4A) en texte.
  • Gestion des Assistants : Création, modification, suppression et récupération d'assistants IA.
  • Gestion des Threads : Création, modification, suppression et récupération des threads de discussion.
  • Gestion des Conversations : Création, modification, suppression et récupération des conversations.
  • Authentification : Système d'authentification sécurisé par email/mot de passe avec JWT.
  • Rate Limiting : Contrôle précis du débit des requêtes avec gestion des quotas et des erreurs associées.
  • Retry : Mécanisme de retry automatique et configurable pour une meilleure robustesse.
  • Logging : Système de logging flexible avec protection des données sensibles.
  • Gestion des Erreurs : Types d'erreurs personnalisés pour une gestion fine des erreurs.

Installation

go get github.com/chrlesur/aiyou.golib

Structure du Projet

.
├── aiyou.go # Point d'entrée principal du package
├── pkg
│   └── aiyou
│       ├── assistants.go # Gestion des assistants
│       ├── audio.go # Transcription audio
│       ├── auth.go # Authentification JWT
│       ├── chat.go # Chat completion
│       ├── client.go # Implémentation du client HTTP
│       ├── config.go # Configuration du client
│       ├── conversation.go # Gestion des conversations
│       ├── errors.go # Types d'erreurs personnalisés
│       ├── logging.go # Logging avec protection des données
│       ├── ratelimit.go # Rate limiting
│       ├── retry.go # Logique de retry
│       └── types.go # Types de données communs
├── examples
│ ├── audio.go # Exemple de transcription audio
│ ├── assistants.go # Exemple de gestion des assistants
│ ├── models.go # Exemple d'utilisation des modèles
│ ├── rate_limiting.go # Exemple de rate limiting simple
│ ├── rate_limiting_advanced.go # Exemple de rate limiting avancé
│ ├── simple_client.go # Client en ligne de commande complet
│ └── threads.go # Exemple de gestion des threads
Description des composants principaux
Fichiers racine
  • aiyou.go : Point d'entrée principal du package, expose l'API publique
  • go.mod : Définition du module et de ses dépendances
Package principal (pkg/aiyou)
  • Cœur du client
    • client.go : Implémentation du client HTTP principal
    • config.go : Structures et logique de configuration
    • types.go : Définitions des types de données communs
  • Fonctionnalités
    • chat.go : Implémentation des fonctionnalités de chat
    • audio.go : Gestion de la transcription audio
    • assistants.go : Gestion des assistants IA
    • conversation.go : Gestion des conversations
    • threads.go : Gestion des threads de discussion
  • Infrastructure
    • auth.go : Système d'authentification JWT
    • logging.go : Système de logging avec protection des données sensibles
    • ratelimit.go : Implémentation du rate limiting
    • retry.go : Logique de retry des requêtes
    • errors.go : Types d'erreurs personnalisés
Exemples

Les exemples dans le dossier examples/ démontrent des cas d'utilisation concrets et servent de documentation interactive.

Initialisation du client avec options
import "github.com/chrlesur/aiyou.golib"

// Client simple
client, err := aiyou.NewClient(
    aiyou.WithEmailPassword("votre-email@exemple.com", "votre-mot-de-passe"),
)
if err != nil {
    log.Fatalf("Erreur lors de la création du client : %v", err)
}

// Client avec options avancées
client, err := aiyou.NewClient(
    aiyou.WithEmailPassword("votre-email@exemple.com", "votre-mot-de-passe"),
    aiyou.WithBaseURL("https://ai.dragonflygroup.fr"),
aiyou.WithLogger(customLogger),
aiyou.WithRateLimiter(aiyou.RateLimiterConfig{
        RequestsPerSecond: 2.0,
        BurstSize: 3,
        WaitTimeout: 5 * time.Second,
}),
)
Authentification
Mode Quiet
client, err := aiyou.NewClient(
    aiyou.WithEmailPassword("email@exemple.com", "password"),
    aiyou.WithLogger(quietLogger),
)
Chat Completion

aiyou.golib fournit deux méthodes principales pour le chat completion :

Chat Completion Standard
req := aiyou.ChatCompletionRequest{
    Messages: []aiyou.Message{
        {
            Role: "user",
            Content: []aiyou.ContentPart{
                {Type: "text", Text: "Quelle est la capitale de la France ?"},
            },
        },
    },
    AssistantID: "id-de-votre-assistant",
}
resp, err := client.ChatCompletion(context.Background(), req)
if err != nil {
    log.Fatalf("Erreur lors du chat completion : %v", err)
}

fmt.Printf("Réponse de l'IA : %s\n", resp.Choices[0].Message.Content[0].Text)
Chat Completion en Streaming
streamReq := aiyou.ChatCompletionRequest{
    Messages: []aiyou.Message{
        {
            Role: "user",
            Content: []aiyou.ContentPart{
                {Type: "text", Text: "Raconte-moi une courte histoire."},
            },
        },
    },
    AssistantID: "id-de-votre-assistant",
    Stream: true,
}

stream, err := client.ChatCompletionStream(context.Background(), streamReq)
if err != nil {
    log.Fatalf("Erreur lors du chat completion en streaming : %v", err)
}

for {
    chunk, err := stream.ReadChunk()
    if err == io.EOF {
        break
    }
    if err != nil {
        log.Fatalf("Erreur lors de la lecture du chunk : %v", err)
    }
    fmt.Print(chunk.Choices[0].Delta.Content)
}
Transcription Audio

Le package supporte la transcription de fichiers audio :

// Transcription simple
opts := &aiyou.AudioTranscriptionRequest{
    Language: "fr",
    Format: "text",
}

transcription, err := client.TranscribeAudioFile(context.Background(), "chemin/vers/audio.wav", opts)
if err != nil {
    log.Fatalf("Erreur de transcription: %v", err)
}
fmt.Println(transcription.Transcription)

Utilisation via la ligne de commande :

go run examples/audio.go --email="user@example.com" --password="pass" --file="audio.wav" --lang="fr" --format="text"

Formats supportés :

  • WAV (jusqu'à 25MB)
  • MP3 (jusqu'à 25MB)
  • M4A (jusqu'à 25MB)
Gestion des erreurs et Retry

Le package aiyou.golib implémente une gestion avancée des erreurs et un système de retry.

Types d'erreurs personnalisés
  • APIError: Erreurs retournées par l'API AI.YOU
  • AuthenticationError: Erreurs liées à l'authentification
  • RateLimitError: Erreurs de dépassement de limite de taux
  • NetworkError: Erreurs de réseau
Système de retry
client, err := aiyou.NewClient(
    aiyou.WithEmailPassword("your-email@example.com", "your-password"),
    aiyou.WithRetry(3, time.Second),
)
Logging

Le package inclut un système de logging flexible qui protège les informations sensibles.

Configuration du Logger
customLogger := aiyou.NewDefaultLogger(os.Stdout)
client, err := aiyou.NewClient(
    aiyou.WithEmailPassword("your-email@example.com", "your-password"),
    aiyou.WithLogger(customLogger),
)
Niveaux de Log

Le système de logging supporte quatre niveaux :

  • DEBUG : Informations détaillées de débogage

  • INFO : Informations opérationnelles générales

  • WARN : Messages d'avertissement

  • ERROR : Messages d'erreur

    customLogger.SetLevel(aiyou.DEBUG)

Rate Limiting

aiyou.golib inclut un système de rate limiting configurable pour contrôler le débit des requêtes.

Configuration du Rate Limiting
client, err := aiyou.NewClient(
    aiyou.WithEmailPassword("your-email@example.com", "your-password"),
    aiyou.WithRateLimiter(aiyou.RateLimiterConfig{
        RequestsPerSecond: 10,
        BurstSize: 5,
        WaitTimeout: 5 * time.Second,
    }),
)
Gestion des Erreurs de Rate Limiting
resp, err := client.ChatCompletion(ctx, req)
if err != nil {
    switch e := err.(type) {
        case *aiyou.RateLimitError:
            if e.IsClientSide {
                fmt.Printf("Rate limit local dépassé. Réessayer dans %d secondes\n", e.RetryAfter)
            } else {
                fmt.Printf("Quota API dépassé. Réessayer dans %d secondes\n", e.RetryAfter)
            }
    }
    return
}
Utilisation avec des Requêtes Concurrentes
var wg sync.WaitGroup
for i := 0; i < 10; i++ {
    wg.Add(1)
    go func(i int) {
        defer wg.Done()

        ctx := context.Background()
        msg := aiyou.NewTextMessage("user", fmt.Sprintf("Request %d", i))

        resp, err := client.CreateChatCompletion(ctx, []aiyou.Message{msg}, "assistant-id")
        if err != nil {
            log.Printf("Request %d failed: %v", i, err)
            return
        }
        log.Printf("Request %d successful", i)
    }(i)
}
wg.Wait()

Exemples

Des exemples complets sont disponibles dans le dossier examples/ :

  • Chat interactif avec historique et commandes go run examples/simple_client.go --email="user@example.com" --password="pass" --assistant="asst_123"

  • Gestion des assistants go run examples/assistants.go --email="user@example.com" --password="pass"

  • Test de rate limiting simple go run examples/rate_limiting.go --email="user@example.com" --password="pass" --rate=2.0

  • Test de rate limiting avancé go run examples/rate_limiting_advanced.go --email="user@example.com" --password="pass" --requests=20 --rate=1.0 --burst=2

  • Transcription audio go run examples/audio.go --email="user@example.com" --password="pass" --file="audio.wav" --lang="fr"

Options communes des exemples

Tous les exemples supportent les options suivantes :

  • --email : Email pour l'authentification
  • --password : Mot de passe
  • --url : URL de base de l'API (optionnel)
  • --debug : Active les logs de debug
  • --quiet : Mode silencieux

Changelog

v1.2.3 (2024-02-09)
🐛 Corrections de bugs
  • Streaming: Amélioration de la gestion des messages en streaming dans chat.go
    • Correction du traitement des messages SSE (Server-Sent Events)
    • Meilleure gestion du préfixe "data: " dans les chunks
    • Ajout d'une validation plus robuste des messages
    • Gestion améliorée des messages vides et invalides
    • Logging plus détaillé pour le débogage
// Exemple de la nouvelle implémentation de ReadChunk
func (sr *StreamReader) ReadChunk() (*ChatCompletionResponse, error) {
    line, err := sr.reader.ReadBytes('\n')
    if err != nil {
        if err == io.EOF {
            return nil, err
        }
        sr.logger.Errorf("Error reading stream: %v", err)
        return nil, err
    }

    // Nettoyage et validation des chunks
    line = bytes.TrimSpace(line)
    if len(line) == 0 {
        return sr.ReadChunk()
    }

    // Gestion améliorée des messages SSE
    if bytes.HasPrefix(line, []byte("data: ")) {
        line = bytes.TrimPrefix(line, []byte("data: "))
    } else {
        sr.logger.Debugf("Skipping non-data line: %s", string(line))
        return sr.ReadChunk()
    }

    // ... reste de l'implémentation
}
🌟 Améliorations
  • Ajout de logs plus détaillés pour le débogage des problèmes de streaming
  • Meilleure gestion des erreurs avec récupération automatique
  • Support amélioré des messages de keep-alive

Contribution

Les contributions sont les bienvenues ! N'hésitez pas à ouvrir une issue ou à soumettre une pull request.

Licence

Ce projet est sous licence GNU General Public License v3.0 (GPL-3.0). Voir le fichier LICENSE pour plus de détails.

Documentation

Overview

Package aiyou provides a client for interacting with the AI.YOU API from Cloud Temple. It supports both email/password and bearer token authentication methods.

Index

Constants

View Source 
const (
	DEBUG = internal.DEBUG // Niveau de log pour le développement
	INFO  = internal.INFO  // Niveau de log pour les informations générales
	WARN  = internal.WARN  // Niveau de log pour les avertissements
	ERROR = internal.ERROR // Niveau de log pour les erreurs
)

Constantes de niveau de log

Variables

View Source 
var SupportedFormats = internal.SupportedFormats // Formats audio supportés

Variables exportées

Functions

func MaskSensitiveInfo 

func MaskSensitiveInfo(input string) string

Fonctions utilitaires de sécurité et logging

func SafeLog 

func SafeLog(logger Logger) func(level LogLevel, format string, args ...interface{})

Types

type APIError 

type APIError = internal.APIError // Erreurs API générales

Types d'erreurs personnalisées

type Assistant 

type Assistant = internal.Assistant

Structures des assistants et threads

type AssistantsResponse 

type AssistantsResponse = internal.AssistantsResponse

Réexportation des types publics

type AudioTranscriptionRequest 

type AudioTranscriptionRequest = internal.AudioTranscriptionRequest

Structures audio

type AudioTranscriptionResponse 

type AudioTranscriptionResponse = internal.AudioTranscriptionResponse

Réexportation des types publics

type AuthenticationError 

type AuthenticationError = internal.AuthenticationError // Erreurs d'authentification

Réexportation des types publics

type Authenticator 

type Authenticator = internal.Authenticator // Interface pour l'authentification (JWT ou Bearer)

Interfaces fondamentales

type ChatCompletionRequest 

type ChatCompletionRequest = internal.ChatCompletionRequest // Requête de completion de chat

Structures de chat completion

type ChatCompletionResponse 

type ChatCompletionResponse = internal.ChatCompletionResponse // Réponse de completion

Réexportation des types publics

type Choice 

type Choice = internal.Choice // Choix de réponse

Réexportation des types publics

type Client 

type Client = internal.Client

Client et options de configuration

func NewClient 

func NewClient(options ...ClientOption) (*Client, error)

NewClient crée un nouveau client AI.YOU Supporte deux méthodes d'authentification : 1. Email/Mot de passe : NewClient("email@example.com", "password") 2. Bearer Token : NewClient("", "", WithBearerToken("your-token"))

type ClientInterface 

type ClientInterface interface {
	// Configuration
	SetBaseURL(url string)
	SetLogger(logger Logger)

	// Opérations de chat
	CreateChatCompletion(ctx context.Context, messages []Message, assistantID string) (*ChatCompletionResponse, error)
	CreateChatCompletionStream(ctx context.Context, messages []Message, assistantID string) (*StreamReader, error)
	ChatCompletion(ctx context.Context, req ChatCompletionRequest) (*ChatCompletionResponse, error)
	ChatCompletionStream(ctx context.Context, req ChatCompletionRequest) (*StreamReader, error)

	// Opérations sur les assistants et modèles
	GetUserAssistants(ctx context.Context) (*AssistantsResponse, error)
	CreateModel(ctx context.Context, req ModelRequest) (*ModelResponse, error)
	GetModels(ctx context.Context) (*ModelsResponse, error)

	// Opérations sur les conversations
	SaveConversation(ctx context.Context, req SaveConversationRequest) (*SaveConversationResponse, error)
	GetConversation(ctx context.Context, threadID string) (*ConversationThread, error)
	GetUserThreads(ctx context.Context, params *UserThreadsParams) (*UserThreadsOutput, error)
	DeleteThread(ctx context.Context, threadID string) error

	// Opérations audio
	TranscribeAudioFile(ctx context.Context, filePath string, opts *AudioTranscriptionRequest) (*AudioTranscriptionResponse, error)
}

Interface du Client définissant toutes les opérations disponibles

type ClientOption 

type ClientOption = internal.ClientOption

Réexportation des types publics

func WithBaseURL 

func WithBaseURL(url string) ClientOption

func WithBearerToken added in v1.2.0 

func WithBearerToken(token string) ClientOption

WithBearerToken configure le client pour utiliser l'authentification par bearer token

func WithEmailPassword added in v1.2.0 

func WithEmailPassword(email, password string) ClientOption

WithEmailPassword configure le client pour utiliser l'authentification par email/mot de passe

func WithLogger 

func WithLogger(logger Logger) ClientOption

Options de configuration du client

func WithRateLimiter 

func WithRateLimiter(config RateLimiterConfig) ClientOption

func WithRetry 

func WithRetry(maxRetries int, initialDelay time.Duration) ClientOption

type ContentPart 

type ContentPart = internal.ContentPart // Partie de contenu d'un message (texte, image, etc.)

Réexportation des types publics

type ConversationThread 

type ConversationThread = internal.ConversationThread

Structures des conversations

type Delta added in v1.0.0 

type Delta = internal.Delta // Pour le streaming

Réexportation des types publics

type LogLevel 

type LogLevel = internal.LogLevel

Types de log

type Logger 

type Logger = internal.Logger // Interface pour le logging personnalisé

Réexportation des types publics

func NewDefaultLogger 

func NewDefaultLogger(w io.Writer) Logger

NewDefaultLogger crée un nouveau logger avec la configuration par défaut

type LoginRequest 

type LoginRequest = internal.LoginRequest // Requête d'authentification par email/mot de passe

Structures d'authentification

type LoginResponse 

type LoginResponse = internal.LoginResponse // Réponse contenant le token JWT

Réexportation des types publics

type Message 

type Message = internal.Message // Représente un message dans la conversation

Structures de messages et contenus

func NewImageMessage 

func NewImageMessage(role, imageURL string) Message

func NewTextMessage 

func NewTextMessage(role, text string) Message

Fonctions utilitaires pour la création de messages

type MessageBuilder 

type MessageBuilder = internal.MessageBuilder

Réexportation des types publics

func NewMessageBuilder 

func NewMessageBuilder(role string, logger Logger) *MessageBuilder

NewMessageBuilder crée un nouveau builder pour construire des messages complexes

type Model 

type Model = internal.Model

Structures des modèles

type ModelProperties 

type ModelProperties = internal.ModelProperties

Réexportation des types publics

type ModelRequest 

type ModelRequest = internal.ModelRequest

Réexportation des types publics

type ModelResponse 

type ModelResponse = internal.ModelResponse

Réexportation des types publics

type ModelsResponse 

type ModelsResponse = internal.ModelsResponse

Réexportation des types publics

type NetworkError 

type NetworkError = internal.NetworkError // Erreurs réseau

Réexportation des types publics

type RateLimitError 

type RateLimitError = internal.RateLimitError // Erreurs de limitation de débit

Réexportation des types publics

type RateLimiter 

type RateLimiter = internal.RateLimiter

Réexportation des types publics

func NewRateLimiter 

func NewRateLimiter(config RateLimiterConfig, logger Logger) *RateLimiter

NewRateLimiter crée un nouveau rate limiter avec la configuration spécifiée

type RateLimiterConfig 

type RateLimiterConfig = internal.RateLimiterConfig

Réexportation des types publics

type SaveConversationRequest 

type SaveConversationRequest = internal.SaveConversationRequest

Réexportation des types publics

type SaveConversationResponse 

type SaveConversationResponse = internal.SaveConversationResponse

Réexportation des types publics

type StreamOptions added in v1.0.0 

type StreamOptions = internal.StreamOptions

Réexportation des types publics

type StreamReader 

type StreamReader = internal.StreamReader

Réexportation des types publics

type SupportedAudioFormat 

type SupportedAudioFormat = internal.SupportedAudioFormat

Réexportation des types publics

type ThreadFilter 

type ThreadFilter = internal.ThreadFilter

Réexportation des types publics

type ThreadHistory added in v1.0.0 

type ThreadHistory = internal.ThreadHistory

Réexportation des types publics

type Usage 

type Usage = internal.Usage // Statistiques d'utilisation

Réexportation des types publics

type User 

type User = internal.User

Réexportation des types publics

type UserThreadsOutput added in v1.0.0 

type UserThreadsOutput = internal.UserThreadsOutput

Réexportation des types publics

type UserThreadsParams added in v1.0.0 

type UserThreadsParams = internal.UserThreadsParams

Réexportation des types publics

Source Files

View all Source files

Directories

Path Synopsis
pkg
aiyou
assistants.go
 assistants.go

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.