저는 클라우드에서 LLM 애플리케이션을 구축해 왔습니다. 또한 MVP나 프로토타입에 매우 적합하고 프로덕션 준비를 위해 약간의 작업이 필요한 LLM 앱을 만드는 많은 개발자를 보았습니다. 나열된 사례 중 하나 이상을 적용하면 애플리케이션을 효과적으로 확장하는 데 도움이 될 수 있습니다. 이 기사에서는 애플리케이션 개발의 전체 소프트웨어 엔지니어링 측면을 다루지 않고 LLM 래퍼 애플리케이션에 대해서만 다룹니다. 또한 코드 조각은 Python으로 되어 있으며 다른 언어에도 동일한 논리를 적용할 수 있습니다.
LiteLLM 또는 LangChain과 같은 미들웨어를 사용하면 공급업체 종속을 방지하고 진화하는 모델 간에 쉽게 전환할 수 있습니다.
파이썬:
from litellm import completion
response = completion(
model="gpt-3.5-turbo",
messages=[{"role": "user", "content": "Hello, how are you?"}]
)
LiteLLM 및 LangChain과 같은 미들웨어 솔루션은 애플리케이션과 다양한 LLM 제공자 간의 추상화 계층을 제공합니다. 이 추상화를 사용하면 핵심 애플리케이션 코드를 변경하지 않고도 다양한 모델이나 공급자 간에 쉽게 전환할 수 있습니다. AI 환경이 빠르게 발전함에 따라 향상된 기능을 갖춘 새로운 모델이 자주 출시됩니다. 미들웨어를 사용하면 성능, 비용 또는 기능 요구 사항에 따라 이러한 새로운 모델을 신속하게 채택하거나 공급자를 전환하여 애플리케이션을 최신 상태로 유지하고 경쟁력을 유지할 수 있습니다.
API 호출에 재시도 논리를 구현하여 속도 제한 문제를 방지하세요.
파이썬:
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
LLM 제공업체는 남용을 방지하고 공정한 사용을 보장하기 위해 요율 제한을 적용하는 경우가 많습니다. 지수 백오프를 사용하여 재시도 메커니즘을 구현하면 애플리케이션이 일시적인 오류나 속도 제한 오류를 원활하게 처리하는 데 도움이 됩니다. 이 접근 방식은 실패한 요청을 자동으로 재시도하여 애플리케이션의 안정성을 높이고 일시적인 문제로 인한 서비스 중단 가능성을 줄입니다. 지수 백오프 전략(재시도 간 지연 증가)은 즉각적인 재요청으로 인해 API가 과부하되어 속도 제한 문제가 악화되는 것을 방지하는 데 도움이 됩니다.
단일 LLM 제공업체에만 의존하지 마세요. 할당량 문제 또는 서비스 중단을 처리하기 위해 대체를 구현합니다.
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")
단일 LLM 제공업체에 의존하면 해당 제공업체에 다운타임이 발생하거나 할당량 한도에 도달하는 경우 서비스가 중단될 수 있습니다. 대체 옵션을 구현하면 애플리케이션의 지속적인 작동이 보장됩니다. 또한 이 접근 방식을 사용하면 다양한 작업에 대해 다양한 공급자나 모델의 장점을 활용할 수 있습니다. LiteLLM은 여러 공급자를 위한 통합 인터페이스를 제공하여 이 프로세스를 단순화하고 공급자 간 전환이나 대체 논리 구현을 더 쉽게 만듭니다.
LLM 추적 및 디버깅을 위해 Langfuse 또는 Helicone과 같은 도구를 사용하세요.
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!"}]
)
관측성 구현의 장점:
관찰 도구는 LLM 애플리케이션의 성능, 사용 패턴 및 잠재적인 문제에 대한 중요한 통찰력을 제공합니다. LLM과의 상호 작용을 실시간으로 모니터링 및 분석하여 프롬프트를 최적화하고 병목 현상을 식별하며 AI 생성 응답의 품질을 보장할 수 있습니다. 이러한 수준의 가시성은 시간이 지남에 따라 애플리케이션을 유지 관리, 디버깅 및 개선하는 데 필수적입니다.
코드나 텍스트 파일에 프롬프트를 하드코딩하는 대신 버전 관리 기능이 있는 프롬프트 관리 도구를 사용하세요.
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")}]
)
LLM 지원서를 유지하고 개선하려면 효과적인 신속한 관리가 중요합니다. 전용 프롬프트 관리 도구를 사용하면 프롬프트 버전을 관리하고, 다양한 변형을 A/B 테스트하고, 애플리케이션 전체에서 쉽게 업데이트할 수 있습니다. 이 접근 방식은 애플리케이션 코드에서 프롬프트 논리를 분리하므로 핵심 애플리케이션을 변경하지 않고도 프롬프트에서 더 쉽게 반복할 수 있습니다. 또한 기술 전문가가 아닌 팀원도 신속한 개선에 기여하고 AI 상호 작용을 개선하는 데 있어 더 나은 협업을 가능하게 합니다.
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.
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.
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.
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.
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.
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.
위 내용은 강력한 LLM 애플리케이션 구축을 위한 필수 실습의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!
![[웹 프런트엔드] Node.js 빠른 시작](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
