ChatsAPI — Le framework d'agents IA le plus rapide au monde

GitHub : https://github.com/chatsapi/ChatsAPI
Bibliothèque : https://pypi.org/project/chatsapi/

L'intelligence artificielle a transformé les industries, mais son déploiement efficace reste un défi de taille. Les cadres complexes, les temps de réponse lents et les courbes d'apprentissage abruptes créent des obstacles aussi bien pour les entreprises que pour les développeurs. Entrez dans ChatsAPI : un cadre d'agent d'IA révolutionnaire et hautes performances conçu pour offrir une vitesse, une flexibilité et une simplicité inégalées.

Dans cet article, nous découvrirons ce qui rend ChatsAPI unique, pourquoi elle change la donne et comment elle permet aux développeurs de créer des systèmes intelligents avec une facilité et une efficacité inégalées.

Qu'est-ce qui rend ChatsAPI unique ?

ChatsAPI n'est pas simplement un autre framework d'IA ; c’est une révolution dans les interactions basées sur l’IA. Voici pourquoi :

• Performances inégalées ChatsAPI exploite les intégrations SBERT, HNSWlib et BM25 Hybrid Search pour fournir le système de correspondance de requêtes le plus rapide jamais construit.

Vitesse : avec des temps de réponse inférieurs à la milliseconde, ChatsAPI est le framework d'agent IA le plus rapide au monde. Sa recherche basée sur HNSWlib garantit une récupération ultra-rapide des itinéraires et des connaissances, même avec de grands ensembles de données.

Efficacité : L'approche hybride du SBERT et du BM25 combine la compréhension sémantique avec les systèmes de classement traditionnels, garantissant à la fois rapidité et précision.

• Intégration transparente avec les LLM
  ChatsAPI prend en charge les grands modèles linguistiques (LLM) de pointe comme OpenAI, Gemini, LlamaAPI et Ollama. Il simplifie la complexité de l'intégration des LLM dans vos applications, vous permettant de vous concentrer sur la création de meilleures expériences.

• Correspondance d'itinéraire dynamique
  ChatsAPI utilise la compréhension du langage naturel (NLU) pour faire correspondre dynamiquement les requêtes des utilisateurs aux itinéraires prédéfinis avec une précision inégalée.

Enregistrez les itinéraires sans effort auprès de décorateurs comme @trigger.

Utilisez l'extraction de paramètres avec @extract pour simplifier la gestion des entrées, quelle que soit la complexité de votre cas d'utilisation.

• Simplicité dans la conception Nous pensons que puissance et simplicité peuvent coexister. Avec ChatsAPI, les développeurs peuvent créer des systèmes robustes basés sur l'IA en quelques minutes. Plus besoin de lutter avec des configurations ou des configurations compliquées.

Les avantages de ChatsAPI

Gestion des requêtes hautes performances
Les systèmes d'IA traditionnels ont des difficultés en termes de vitesse ou de précision : ChatsAPI offre les deux. Qu'il s'agisse de trouver la meilleure correspondance dans une vaste base de connaissances ou de gérer de gros volumes de requêtes, ChatsAPI excelle.

Cadre flexible
ChatsAPI s'adapte à tous les cas d'utilisation, que vous construisiez :

• Chatbots de support client.
• Systèmes de recherche intelligents.
• Assistants basés sur l'IA pour le commerce électronique, la santé ou l'éducation.

Conçu pour les développeurs

Conçu par des développeurs, pour des développeurs, ChatsAPI propose :

• Démarrage rapide : configurez votre environnement, définissez des itinéraires et lancez le direct en quelques étapes seulement.
• Personnalisation : adaptez le comportement avec les décorateurs et affinez les performances en fonction de vos besoins spécifiques.
• Intégration LLM facile : basculez entre les LLM pris en charge comme OpenAI ou Gemini avec un minimum d'effort.

Comment fonctionne ChatsAPI ?

À la base, ChatsAPI fonctionne selon un processus en trois étapes :

1. Enregistrer des itinéraires : utilisez le décorateur @trigger pour définir des itinéraires et les associer à vos fonctions.
2. Recherche et correspondance : ChatsAPI utilise les intégrations SBERT et la recherche hybride BM25 pour faire correspondre dynamiquement les entrées de l'utilisateur avec les bons itinéraires.
3. Extraire les paramètres : avec le décorateur @extract, ChatsAPI extrait et valide automatiquement les paramètres, ce qui facilite la gestion des entrées complexes.

Le résultat ? Un système rapide, précis et ridiculement facile à utiliser.

Cas d'utilisation

• Support client
  Automatisez les interactions avec les clients grâce à une résolution ultra-rapide des requêtes. ChatsAPI garantit aux utilisateurs d'obtenir instantanément des réponses pertinentes, améliorant ainsi la satisfaction et réduisant les coûts opérationnels.

• Recherche dans la base de connaissances
  Permettez aux utilisateurs de parcourir de vastes bases de connaissances avec une compréhension sémantique. L'approche hybride SBERT-BM25 garantit des résultats précis et contextuels.

• IA conversationnelle
  Créez des agents d'IA conversationnels qui comprennent et s'adaptent aux entrées des utilisateurs en temps réel. ChatsAPI s'intègre parfaitement aux meilleurs LLM pour offrir des conversations naturelles et engageantes.

Pourquoi devriez-vous vous en soucier ?

D'autres frameworks promettent flexibilité ou performances, mais aucun ne peut offrir les deux comme ChatsAPI. Nous avons créé un cadre qui est :

• Plus rapide que tout ce qui existe sur le marché.
• Plus simple à configurer et à utiliser.
• Plus intelligent, avec son moteur de recherche hybride unique qui mélange des approches sémantiques et basées sur des mots clés.

ChatsAPI permet aux développeurs de libérer tout le potentiel de l'IA, sans les maux de tête liés à la complexité ou au ralentissement des performances.

Comment commencer

Démarrer avec ChatsAPI est simple :

• Installez le framework :

pip install chatsapi

• Définissez vos itinéraires :

from chatsapi import ChatsAPI  

chat = ChatsAPI()  

@chat.trigger("Hello")  
async def greet(input_text):  
    return "Hi there!"

• Extraire quelques données du message

from chatsapi import ChatsAPI  

chat = ChatsAPI()  

@chat.trigger("Need help with account settings.")
@chat.extract([
    ("account_number", "Account number (a nine digit number)", int, None),
    ("holder_name", "Account holder's name (a person name)", str, None)
])
async def account_help(chat_message: str, extracted: dict):
    return {"message": chat_message, "extracted": extracted}
Run your message (with no LLM)
@app.post("/chat")
async def message(request: RequestModel, response: Response):
    reply = await chat.run(request.message)
    return {"message": reply}

• Conversations (avec LLM) — Exemple complet

import os
from dotenv import load_dotenv
from fastapi import FastAPI, Request, Response
from pydantic import BaseModel
from chatsapi.chatsapi import ChatsAPI

# Load environment variables from .env file
load_dotenv()

app = FastAPI()                 # instantiate FastAPI or your web framework
chat = ChatsAPI(                # instantiate ChatsAPI
    llm_type="gemini",
    llm_model="models/gemini-pro",
    llm_api_key=os.getenv("GOOGLE_API_KEY"),
)

# chat trigger - 1
@chat.trigger("Want to cancel a credit card.")
@chat.extract([("card_number", "Credit card number (a 12 digit number)", str, None)])
async def cancel_credit_card(chat_message: str, extracted: dict):
    return {"message": chat_message, "extracted": extracted}

# chat trigger - 2
@chat.trigger("Need help with account settings.")
@chat.extract([
    ("account_number", "Account number (a nine digit number)", int, None),
    ("holder_name", "Account holder's name (a person name)", str, None)
])
async def account_help(chat_message: str, extracted: dict):
    return {"message": chat_message, "extracted": extracted}

# request model
class RequestModel(BaseModel):
    message: str

# chat conversation
@app.post("/chat")
async def message(request: RequestModel, response: Response, http_request: Request):
    session_id = http_request.cookies.get("session_id")
    reply = await chat.conversation(request.message, session_id)

    return {"message": f"{reply}"}

# set chat session
@app.post("/set-session")
def set_session(response: Response):
    session_id = chat.set_session()
    response.set_cookie(key="session_id", value=session_id)
    return {"message": "Session set"}

# end chat session
@app.post("/end-session")
def end_session(response: Response, http_request: Request):
    session_id = http_request.cookies.get("session_id")
    chat.end_session(session_id)
    response.delete_cookie("session_id")
    return {"message": "Session ended"}

• Routes adhérant aux requêtes LLM — Requête unique

await chat.query(request.message)

Repères

Les méthodes traditionnelles basées sur LLM (API) prennent généralement environ quatre secondes par requête. En revanche, ChatsAPI traite les requêtes en moins d'une seconde, souvent en quelques millisecondes, sans effectuer d'appels API LLM.

Effectuer une tâche de routage de chat dans un délai de 472 ms (pas de cache)

Effectuer une tâche de routage de chat dans un délai de 21 ms (après le cache)

Effectuer une tâche d'extraction de données de routage de chat dans un délai de 862 ms (pas de cache)

Démontrer ses capacités conversationnelles avec l'API WhatsApp Cloud

ChatsAPI — Hiérarchie des fonctionnalités

ChatsAPI est plus qu'un simple framework ; c’est un changement de paradigme dans la façon dont nous construisons et interagissons avec les systèmes d’IA. En combinant vitesse, précision et facilité d'utilisation, ChatsAPI établit une nouvelle référence pour les frameworks d'agents IA.

Rejoignez la révolution aujourd'hui et découvrez pourquoi ChatsAPI transforme le paysage de l'IA.

Prêt à plonger ? Commencez dès maintenant avec ChatsAPI et découvrez l'avenir du développement de l'IA.

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!