Pratiques essentielles pour créer des applications LLM robustes

Introduction

J'ai créé des applications LLM dans le cloud. J'ai également vu beaucoup de développeurs créer des applications LLM qui sont très utiles pour un MVP ou un prototype et nécessitent un peu de travail pour les rendre prêtes pour la production. Une ou plusieurs des pratiques répertoriées, lorsqu’elles sont appliquées, peuvent aider votre application à évoluer de manière efficace. Cet article ne couvre pas tout l'aspect génie logiciel du développement d'applications mais plutôt uniquement les applications wrapper LLM. De plus, les extraits de code sont en python et la même logique peut également être appliquée à d'autres langages.

1. Tirez parti du middleware pour plus de flexibilité

Utilisez des middlewares comme LiteLLM ou LangChain pour éviter le lock-in fournisseur et basculer facilement entre les modèles à mesure qu'ils évoluent.

Python :

from litellm import completion

response = completion(
    model="gpt-3.5-turbo", 
    messages=[{"role": "user", "content": "Hello, how are you?"}]
)

Les solutions middleware telles que LiteLLM et LangChain fournissent une couche d'abstraction entre votre application et divers fournisseurs LLM. Cette abstraction vous permet de basculer facilement entre différents modèles ou fournisseurs sans modifier le code de votre application principale. À mesure que le paysage de l’IA évolue rapidement, de nouveaux modèles dotés de capacités améliorées sont fréquemment lancés. En utilisant un middleware, vous pouvez rapidement adopter ces nouveaux modèles ou changer de fournisseur en fonction des exigences en matière de performances, de coûts ou de fonctionnalités, garantissant ainsi que votre application reste à jour et compétitive.

2. Mettre en œuvre des mécanismes de nouvelle tentative

Évitez les problèmes de limite de débit en implémentant une logique de nouvelle tentative dans vos appels API.

Python :

import time
from openai import OpenAI

client = OpenAI()

def retry_api_call(max_retries=3, delay=1):
    for attempt in range(max_retries):
        try:
            response = client.chat.completions.create(
                model="gpt-3.5-turbo",
                messages=[{"role": "user", "content": "Hello!"}]
            )
            return response
        except Exception as e:
            if attempt == max_retries - 1:
                raise e
            time.sleep(delay * (2 ** attempt))  # Exponential backoff

Les fournisseurs de LLM imposent souvent des limites de tarifs pour éviter les abus et garantir une utilisation équitable. La mise en œuvre d'un mécanisme de nouvelle tentative avec une interruption exponentielle aide votre application à gérer efficacement les pannes temporaires ou les erreurs de limite de débit. Cette approche augmente la fiabilité de votre application en réessayant automatiquement les demandes ayant échoué, réduisant ainsi les risques d'interruptions de service dues à des problèmes temporaires. La stratégie d'attente exponentielle (augmentant le délai entre les tentatives) permet d'éviter de surcharger l'API avec de nouvelles requêtes immédiates, ce qui pourrait exacerber les problèmes de limitation de débit.

3. Configurer les solutions de secours du fournisseur LLM

Ne comptez pas sur un seul fournisseur de LLM. Mettez en œuvre des solutions de secours pour gérer les problèmes de quotas ou les interruptions de service.

from litellm import completion

def get_llm_response(prompt):
    providers = ['openai/gpt-3.5-turbo', 'anthropic/claude-2', 'cohere/command-nightly']
    for provider in providers:
        try:
            response = completion(model=provider, messages=[{"role": "user", "content": prompt}])
            return response
        except Exception as e:
            print(f"Error with {provider}: {str(e)}")
            continue
    raise Exception("All LLM providers failed")

Le recours à un seul fournisseur LLM peut entraîner des interruptions de service si ce fournisseur subit des temps d'arrêt ou si vous atteignez les limites de quota. En mettant en œuvre des options de repli, vous assurez le fonctionnement continu de votre application. Cette approche vous permet également de tirer parti des atouts de différents fournisseurs ou modèles pour diverses tâches. LiteLLM simplifie ce processus en fournissant une interface unifiée pour plusieurs fournisseurs, facilitant ainsi le basculement entre eux ou la mise en œuvre d'une logique de secours.

4. Mettre en œuvre l'observabilité

Utilisez des outils comme Langfuse ou Helicone pour le traçage et le débogage LLM.

from langfuse.openai import OpenAI

client = OpenAI(
    api_key="your-openai-api-key",
    langfuse_public_key="your-langfuse-public-key",
    langfuse_secret_key="your-langfuse-secret-key"
)

response = client.chat.completions.create(
    model="gpt-3.5-turbo",
    messages=[{"role": "user", "content": "Hello, AI!"}]
)

Avantages de la mise en œuvre de l'observabilité :

• Débogage amélioré : suivez et rejouez facilement les conversations pour identifier les problèmes.
• Optimisation des performances : obtenez des informations sur les temps de réponse et les performances du modèle.
• Gestion des coûts : suivez l'utilisation des jetons et les coûts associés pour un meilleur contrôle budgétaire.
• Assurance qualité : surveiller la qualité des réponses et identifier les domaines à améliorer.
• Analyse de l'expérience utilisateur : comprenez les interactions des utilisateurs et optimisez les invites en conséquence.
• Conformité et audit : tenir des journaux de conformité réglementaire et d'audits internes.
• Détection des anomalies : identifiez et réagissez rapidement aux modèles ou comportements inhabituels.

Les outils d'observabilité fournissent des informations cruciales sur les performances de votre application LLM, les modèles d'utilisation et les problèmes potentiels. Ils vous permettent de surveiller et d'analyser les interactions avec les LLM en temps réel, vous aidant ainsi à optimiser les invites, à identifier les goulots d'étranglement et à garantir la qualité des réponses générées par l'IA. Ce niveau de visibilité est essentiel pour maintenir, déboguer et améliorer votre application au fil du temps.

5. Gérer efficacement les invites

Utilisez des outils de gestion des invites avec gestion des versions au lieu de coder en dur les invites dans votre code ou vos fichiers texte.

from promptflow import PromptFlow

pf = PromptFlow()

prompt_template = pf.get_prompt("greeting_prompt", version="1.2")
response = openai.ChatCompletion.create(
    model="gpt-3.5-turbo",
    messages=[{"role": "user", "content": prompt_template.format(name="Alice")}]
)

Une gestion efficace des invites est cruciale pour maintenir et améliorer votre application LLM. En utilisant des outils de gestion d'invites dédiés, vous pouvez contrôler la version de vos invites, tester A/B différentes variantes et les mettre à jour facilement dans votre application. Cette approche sépare la logique des invites du code de l'application, ce qui facilite l'itération sur les invites sans modifier l'application principale. Il permet également aux membres non techniques de l'équipe de contribuer à des améliorations rapides et permet une meilleure collaboration pour affiner les interactions avec l'IA.

6. Store Conversation History Persistently

Use a persistent cache like Redis for storing conversation history instead of in-memory cache which is not adapted for distributed systems.

from langchain.memory import RedisChatMessageHistory
from langchain.chains import ConversationChain
from langchain.llms import OpenAI

# Initialize Redis chat message history
message_history = RedisChatMessageHistory(url="redis://localhost:6379/0", ttl=600, session_id="user-123")

# Create a conversation chain with Redis memory
conversation = ConversationChain(
    llm=OpenAI(),
    memory=message_history,
    verbose=True
)

# Use the conversation
response = conversation.predict(input="Hi there!")
print(response)

# The conversation history is automatically stored in Redis

Storing conversation history is essential for maintaining context in ongoing interactions and providing personalized experiences. Using a persistent cache like Redis, especially in distributed systems, ensures that conversation history is reliably stored and quickly accessible. This approach allows your application to scale horizontally while maintaining consistent user experiences across different instances or servers. The use of Redis with LangChain simplifies the integration of persistent memory into your conversational AI system, making it easier to build stateful, context-aware applications.

7. Use JSON Mode whenever possible

Whenever possible like extracting structured information, provide a JSON schema instead of relying on raw text output.

import openai

response = openai.ChatCompletion.create(
    model="gpt-3.5-turbo-1106",
    response_format={"type": "json_object"},
    messages=[
        {"role": "system", "content": "Extract the name and age from the user's input."},
        {"role": "user", "content": "My name is John and I'm 30 years old."}
    ]
)

print(response.choices[0].message.content)
# Output: {"name": "John", "age": 30}

Using JSON mode for information extraction provides a structured and consistent output format, making it easier to parse and process the LLM's responses in your application. This approach reduces the need for complex post-processing of free-form text and minimizes the risk of misinterpretation. It's particularly useful for tasks like form filling, data extraction from unstructured text, or any scenario where you need to integrate AI-generated content into existing data structures or databases.

8. Set Up Credit Alerts

Implement alerts for prepaid credits and per-user credit checks, even in MVP stages.

def check_user_credits(user_id, requested_tokens):
    user_credits = get_user_credits(user_id)
    if user_credits < requested_tokens:
        raise InsufficientCreditsError(f"User {user_id} has insufficient credits")

    remaining_credits = user_credits - requested_tokens
    if remaining_credits < CREDIT_ALERT_THRESHOLD:
        send_low_credit_alert(user_id, remaining_credits)

    return True

Implementing credit alerts and per-user credit checks is crucial for managing costs and ensuring fair usage in your LLM application. This system helps prevent unexpected expenses and allows you to proactively manage user access based on their credit limits. By setting up alerts at multiple thresholds, you can inform users or administrators before credits are depleted, ensuring uninterrupted service. This approach is valuable even in MVP stages, as it helps you understand usage patterns and plan for scaling your application effectively.

9. Implement Feedback Loops

Create mechanisms for users to provide feedback on AI responses, starting with simple thumbs up/down ratings.

def process_user_feedback(response_id, feedback):
    if feedback == 'thumbs_up':
        log_positive_feedback(response_id)
    elif feedback == 'thumbs_down':
        log_negative_feedback(response_id)
        trigger_improvement_workflow(response_id)

# In your API endpoint
@app.route('/feedback', methods=['POST'])
def submit_feedback():
    data = request.json
    process_user_feedback(data['response_id'], data['feedback'])
    return jsonify({"status": "Feedback received"})

Implementing feedback loops is essential for continuously improving your LLM application. By allowing users to provide feedback on AI responses, you can identify areas where the model performs well and where it needs improvement. This data can be used to fine-tune models, adjust prompts, or implement additional safeguards. Starting with simple thumbs up/down ratings provides an easy way for users to give feedback, while more detailed feedback options can be added later for deeper insights. This approach helps in building trust with users and demonstrates your commitment to improving the AI's performance based on real-world usage.

10. Implement Guardrails

Use prompt guards to check for prompt injection attacks, toxic content, and off-topic responses.

import re
from better_profanity import profanity

def check_prompt_injection(input_text):
    injection_patterns = [
        r"ignore previous instructions",
        r"disregard all prior commands",
        r"override system prompt"
    ]
    for pattern in injection_patterns:
        if re.search(pattern, input_text, re.IGNORECASE):
            return True
    return False

def check_toxic_content(input_text):
    return profanity.contains_profanity(input_text)

def sanitize_input(input_text):
    if check_prompt_injection(input_text):
        raise ValueError("Potential prompt injection detected")

    if check_toxic_content(input_text):
        raise ValueError("Toxic content detected")

    # Additional checks can be added here (e.g., off-topic detection)

    return input_text  # Return sanitized input if all checks pass

# Usage
try:
    safe_input = sanitize_input(user_input)
    # Process safe_input with your LLM
except ValueError as e:
    print(f"Input rejected: {str(e)}")

Implementing guardrails is crucial for ensuring the safety and reliability of your LLM application. This example demonstrates how to check for potential prompt injection attacks and toxic content. Prompt injection attacks attempt to override or bypass the system's intended behavior, while toxic content checks help maintain a safe and respectful environment. By implementing these checks, you can prevent malicious use of your AI system and ensure that the content generated aligns with your application's guidelines and ethical standards. Additional checks can be added to detect off-topic responses or other unwanted behaviors, further enhancing the robustness of your application.

Conclusion

All the above listed points can be easily integrated into your application and they prepare you better for scaling in production. You may also agree or disagree on some of the above points. In any case, feel free to post your questions or comments.

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!