Konfiguracja bramy LLM

Claude Code może być skonfigurowany do pracy z niestandardowymi bramami LLM, endpointami przedsiębiorstwa i alternatywnymi dostawcami. Ten przewodnik obejmuje zaawansowane konfiguracje do kierowania żądań LLM przez niestandardową infrastrukturę.

Zrozumienie bram LLM

Typowe scenariusze bram

Brama przedsiębiorstwa

Kieruj wszystkie żądania LLM przez infrastrukturę korporacyjną dla bezpieczeństwa i zgodności

Zarządzanie kosztami

Śledź użycie, implementuj kwoty i optymalizuj wybór modelu na podstawie wymagań zadania

Wielu dostawców

Przełączaj się płynnie między różnymi dostawcami LLM (OpenAI, Anthropic, itp.)

Wdrożenie brzegowe

Używaj modeli lokalnych lub wdrożonych na brzegu dla wrażliwych danych lub scenariuszy offline

Podstawowa konfiguracja bramy

Konfiguracja środowiska

Ustaw niestandardowy endpoint

# Wskaż na swoją bramę LLM
export CLAUDE_API_ENDPOINT=https://llm-gateway.company.com/v1
export CLAUDE_API_KEY=your-gateway-api-key

# Dla kompatybilności z bramami w stylu OpenAI
export OPENAI_API_BASE=https://llm-gateway.company.com/v1
export OPENAI_API_KEY=your-gateway-api-key

Skonfiguruj uwierzytelnianie

# Uwierzytelnianie Bearer token
export CLAUDE_AUTH_TYPE=bearer
export CLAUDE_AUTH_TOKEN=your-bearer-token

# Niestandardowe nagłówki dla bram przedsiębiorstwa
export CLAUDE_CUSTOM_HEADERS='{"X-Department": "Engineering", "X-Project": "ProjectName"}'

Przetestuj połączenie

claude "Testuj połączenie bramy:
- Zweryfikuj czy endpoint jest osiągalny
- Sprawdź uwierzytelnianie
- Testuj dostępność modelu
- Waliduj format odpowiedzi"

Popularne rozwiązania bram

# Zainstaluj proxy LiteLLM
pip install litellm[proxy]

# Uruchom serwer proxy
litellm --model claude-4.1-opus --port 8000

# Skonfiguruj Claude Code
export CLAUDE_API_ENDPOINT=http://localhost:8000
export CLAUDE_API_KEY=dummy-key-for-local

# Z wieloma modelami
cat > litellm_config.yaml << EOF
model_list:
  - model_name: claude-4.1-opus
    litellm_params:
      model: claude-4.1-opus
      api_key: $ANTHROPIC_API_KEY
  - model_name: gpt-4
    litellm_params:
      model: gpt-4
      api_key: $OPENAI_API_KEY
EOF

litellm --config litellm_config.yaml --port 8000

# Uruchom LocalAI z Docker
docker run -p 8080:8080 \
  -v $PWD/models:/models \
  localai/localai:latest

# Skonfiguruj dla lokalnych modeli
export CLAUDE_API_ENDPOINT=http://localhost:8080/v1
export CLAUDE_MODEL_NAME=llama-2-7b-chat

# Pobierz i skonfiguruj modele
claude "Pomóż mi skonfigurować LocalAI z:
- Pobieraniem odpowiednich modeli
- Konfiguracją aliasów modeli
- Ustawieniem parametrów modeli
- Testowaniem odpowiedzi modeli"

# Skonfiguruj MLflow AI Gateway
cat > config.yaml << EOF
routes:
  - name: claude-completions
    route_type: llm/v1/completions
    model:
      provider: anthropic
      name: claude-4.1-opus
      config:
        anthropic_api_key: $ANTHROPIC_API_KEY
  - name: embeddings
    route_type: llm/v1/embeddings
    model:
      provider: openai
      name: text-embedding-ada-002
      config:
        openai_api_key: $OPENAI_API_KEY
EOF

# Uruchom bramę
mlflow gateway start --config-path config.yaml --port 5000

# Skonfiguruj Claude Code
export CLAUDE_API_ENDPOINT=http://localhost:5000/gateway/claude-completions/invocations

Wzorce bram przedsiębiorstwa

Równoważenie obciążenia

Konfiguracja wieloinstancyjna

# Konfiguracja HAProxy dla równoważenia obciążenia LLM
cat > haproxy.cfg << EOF
global
    daemon

defaults
    mode http
    timeout connect 5000ms
    timeout client 300000ms  # 5 minut na odpowiedzi LLM
    timeout server 300000ms

frontend llm_frontend
    bind *:8080
    default_backend llm_servers

backend llm_servers
    balance leastconn  # Najlepsze dla różnych czasów odpowiedzi
    option httpchk GET /health
    server llm1 llm1.internal:8000 check weight 100
    server llm2 llm2.internal:8000 check weight 100
    server llm3 llm3.internal:8000 check weight 50  # Słabsza instancja
EOF

# Skonfiguruj Claude Code do używania load balancera
export CLAUDE_API_ENDPOINT=http://localhost:8080/v1

Kierowanie żądań

Wybór modelu na podstawie zadania

# Przykład niestandardowego routera bramy
from flask import Flask, request, jsonify
import requests

app = Flask(__name__)

@app.route('/v1/completions', methods=['POST'])
def route_request():
    data = request.json
    prompt_length = len(data.get('prompt', ''))

    # Kieruj na podstawie złożoności promptu
    if prompt_length < 500:
        # Użyj szybszego, tańszego modelu dla prostych zadań
        model = 'claude-instant'
        endpoint = 'http://instant-llm:8000'
    elif 'code' in data.get('prompt', '').lower():
        # Użyj specjalizowanego modelu kodowego
        model = 'claude-4.1-opus'
        endpoint = 'http://opus-llm:8000'
    else:
        # Domyślny model
        model = 'claude-4-sonnet'
        endpoint = 'http://sonnet-llm:8000'

    # Przekaż żądanie
    response = requests.post(
        f"{endpoint}/v1/completions",
        json={**data, 'model': model},
        headers=request.headers
    )

    return response.json()

Implementuj circuit breaker

claude "Utwórz bramę circuit breaker która:
- Implementuje logikę ponownych prób z exponential backoff
- Fallback do secondary endpoints
- Monitoruje wskaźniki sukcesu
- Zapewnia endpoint statusu zdrowia"

Bezpieczeństwo i zgodność

Wykrywanie PII

# Middleware bramy do filtrowania PII
@app.before_request
def check_pii():
    if request.method == 'POST':
        data = request.get_json()
        prompt = data.get('prompt', '')

        # Sprawdź wzorce PII
        if detect_pii(prompt):
            return jsonify({
                'error': 'PII wykryte w prompt',
                'type': 'security_violation'
            }), 400

Logowanie audytu

# Kompleksowe logowanie żądań
@app.after_request
def log_request(response):
    log_entry = {
        'timestamp': datetime.utcnow(),
        'user': request.headers.get('X-User-ID'),
        'department': request.headers.get('X-Department'),
        'model': request.json.get('model'),
        'prompt_tokens': count_tokens(request.json.get('prompt')),
        'response_tokens': count_tokens(response.json.get('text')),
        'latency': response.headers.get('X-Process-Time'),
        'status': response.status_code
    }
    audit_logger.info(json.dumps(log_entry))
    return response

Niestandardowe wdrożenie modeli

Serwowanie modeli lokalnych

# Zainstaluj i uruchom Ollama
curl -fsSL https://ollama.ai/install.sh | sh
ollama serve

# Pobierz modele
ollama pull llama2
ollama pull codellama

# Skonfiguruj Claude Code
export CLAUDE_API_ENDPOINT=http://localhost:11434/api
export CLAUDE_MODEL_NAME=codellama

# Testuj lokalny model
claude "Testuj lokalny model Ollama:
- Wygeneruj fragment kodu
- Wyjaśnij funkcjonalność
- Sprawdź jakość odpowiedzi"

# Uruchom serwer vLLM
python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-2-7b-chat-hf \
    --port 8000 \
    --max-model-len 4096

# Skonfiguruj Claude Code
export CLAUDE_API_ENDPOINT=http://localhost:8000/v1
export CLAUDE_MODEL_NAME=meta-llama/Llama-2-7b-chat-hf

# Dostrojenie wydajności
export VLLM_NUM_GPUS=2
export VLLM_TENSOR_PARALLEL_SIZE=2

# Text Generation Inference by HuggingFace
docker run --gpus all --shm-size 1g \
    -p 8080:80 \
    -v $PWD/data:/data \
    ghcr.io/huggingface/text-generation-inference:latest \
    --model-id meta-llama/Llama-2-7b-chat-hf \
    --max-input-length 2048 \
    --max-total-tokens 4096

# Skonfiguruj endpoint
export CLAUDE_API_ENDPOINT=http://localhost:8080
export CLAUDE_API_FORMAT=tgi  # Specjalne obsługiwanie formatu

Wdrożenie brzegowe

Konfiguracja offline-first

# Skonfiguruj łańcuch fallback
export CLAUDE_ENDPOINTS=(
    "http://localhost:8000/v1"  # Najpierw model lokalny
    "https://edge-server.local/v1"  # Serwer brzegowy
    "https://llm-gateway.company.com/v1"  # Brama korporacyjna
    "https://api.anthropic.com/v1"  # Fallback bezpośredniego API
)

# Implementuj logikę fallback
claude "Utwórz skrypt wrapper który:
- Próbuje każdego endpointu po kolei
- Fallback przy błędzie połączenia
- Cachuje udane endpointy
- Monitoruje latencję i dostosowuje kolejność
- Zapewnia możliwości offline"

Zaawansowane konfiguracje

Konfiguracja wielu dostawców

Skonfiguruj kierowanie dostawców

providers:
  anthropic:
    endpoint: https://api.anthropic.com
    api_key: ${ANTHROPIC_API_KEY}
    models: [claude-4.1-opus, claude-4-sonnet]
  openai:
    endpoint: https://api.openai.com
    api_key: ${OPENAI_API_KEY}
    models: [gpt-4, gpt-3.5-turbo]
  cohere:
    endpoint: https://api.cohere.ai
    api_key: ${COHERE_API_KEY}
    models: [command-r-plus]

routing_rules:
  - pattern: "code.*"
    preferred_model: claude-4.1-opus
    fallback: [gpt-4, command-r-plus]
  - pattern: "chat.*"
    preferred_model: gpt-3.5-turbo
    fallback: [claude-4-sonnet]

Implementuj inteligentne kierowanie

claude "Utwórz inteligentny router który:
- Kieruje według złożoności zadania
- Implementuje optymalizację kosztów
- Śledzi użycie tokenów na model
- Zapewnia opcje fallback"

Optymalizacja kosztów

Liczenie tokenów

# Wstępne oszacowanie tokenów
from tiktoken import encoding_for_model

def estimate_cost(prompt, model):
    encoder = encoding_for_model(model)
    prompt_tokens = len(encoder.encode(prompt))

    # Oszacuj tokeny odpowiedzi
    estimated_response = prompt_tokens * 0.75

    # Oblicz koszt
    costs = {
        'claude-4.1-opus': {'input': 0.015, 'output': 0.075},
        'claude-4-sonnet': {'input': 0.003, 'output': 0.015},
        'gpt-4': {'input': 0.03, 'output': 0.06}
    }

    model_cost = costs.get(model, {'input': 0.001, 'output': 0.002})
    total_cost = (prompt_tokens * model_cost['input'] +
                  estimated_response * model_cost['output']) / 1000

    return {
        'prompt_tokens': prompt_tokens,
        'estimated_response_tokens': estimated_response,
        'estimated_cost': total_cost
    }

Kontrole budżetu

# Implementuj limity wydatków
class BudgetGateway:
    def __init__(self, daily_limit=100, user_limits=None):
        self.daily_limit = daily_limit
        self.user_limits = user_limits or {}
        self.usage = defaultdict(float)

    def check_budget(self, user, estimated_cost):
        # Sprawdź dzienny limit
        if self.usage['total'] + estimated_cost > self.daily_limit:
            raise BudgetExceeded("Osiągnięto dzienny limit")

        # Sprawdź limit użytkownika
        user_limit = self.user_limits.get(user, float('inf'))
        if self.usage[user] + estimated_cost > user_limit:
            raise BudgetExceeded(f"Osiągnięto limit użytkownika {user}")

        return True

    def record_usage(self, user, actual_cost):
        self.usage['total'] += actual_cost
        self.usage[user] += actual_cost

Monitorowanie i obserwowalność

Metryki bramy

# Metryki Prometheus do monitorowania bramy
from prometheus_client import Counter, Histogram, Gauge

# Zdefiniuj metryki
request_count = Counter('llm_requests_total', 'Łączne żądania LLM',
                       ['model', 'status', 'user'])
request_duration = Histogram('llm_request_duration_seconds',
                           'Czas trwania żądania LLM', ['model'])
active_requests = Gauge('llm_active_requests', 'Aktywne żądania LLM')
token_usage = Counter('llm_tokens_total', 'Łączne użyte tokeny',
                     ['model', 'type'])

# Instrumentuj bramę
@app.route('/v1/completions', methods=['POST'])
def handle_completion():
    with request_duration.labels(model=request.json['model']).time():
        active_requests.inc()
        try:
            response = process_request(request.json)
            request_count.labels(
                model=request.json['model'],
                status='success',
                user=request.headers.get('X-User-ID')
            ).inc()
            return response
        except Exception as e:
            request_count.labels(
                model=request.json['model'],
                status='error',
                user=request.headers.get('X-User-ID')
            ).inc()
            raise
        finally:
            active_requests.dec()

Kontrole zdrowia

Kompleksowe monitorowanie zdrowia

claude "Utwórz system kontroli zdrowia który monitoruje:
- Dostępność endpointów
- Czasy odpowiedzi
- Wskaźniki błędów
- Trendy użycia tokenów"

Najlepsze praktyki

Rozwiązywanie problemów

Problemy z połączeniem

# Debug połączenia bramy
claude "Debug połączenie bramy:
- Testuj łączność sieciową
- Zweryfikuj uwierzytelnianie
- Sprawdź certyfikaty SSL
- Przeanalizuj nagłówki request/response"

Testowanie wydajności

# Benchmark wydajności bramy
claude "Utwórz test wydajności który:
- Mierzy latencję dla różnych modeli
- Testuje obsługę współbieżnych żądań
- Monitoruje użycie zasobów
- Generuje raport wydajności"

Następne kroki

Eksploruj powiązane zaawansowane tematy:

Konfiguracja proxy dla konfiguracji sieciowej
Kontrola kosztów dla zarządzania budżetem
Monitorowanie kosztów dla śledzenia użycia

Pamiętaj: Bramy LLM zapewniają potężne możliwości dla wdrożeń przedsiębiorstwa. Zacznij prosto i dodawaj złożoność w miarę potrzeb, zawsze zachowując bezpieczeństwo i niezawodność jako najwyższe priorytety.