API LLM dla programistów: Kompletny przewodnik integracji

Ten przewodnik obejmuje wszystko, czego programista potrzebuje do integracji API LLM w aplikacjach produkcyjnych: uwierzytelnianie, strumieniowanie, użycie narzędzi, osadzenia, wzorce RAG i zarządzanie kosztami. Wszystkie przykłady używają formatu zgodnego z OpenAI i działają z APIMaster.ai.

Konfiguracja

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_APIMASTER_KEY",
    base_url="https://apimaster.ai/v1",
)

Podstawowe wzorce

1. Podstawowe uzupełnianie czatu

def ask(prompt: str, model: str = "claude-sonnet-4-6") -> str:
    response = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": prompt}],
    )
    return response.choices[0].message.content

2. Prompt systemowy + rozmowa

class Conversation:
    def __init__(self, system: str, model: str = "claude-sonnet-4-6"):
        self.model = model
        self.messages = [{"role": "system", "content": system}]
    
    def send(self, user_msg: str) -> str:
        self.messages.append({"role": "user", "content": user_msg})
        resp = client.chat.completions.create(
            model=self.model,
            messages=self.messages,
        )
        reply = resp.choices[0].message.content
        self.messages.append({"role": "assistant", "content": reply})
        return reply

bot = Conversation("You are an expert Python developer.")
print(bot.send("What is the GIL?"))
print(bot.send("How do I work around it?"))

3. Strumieniowanie

def stream(prompt: str, model: str = "gpt-5.4"):
    with client.chat.completions.stream(
        model=model,
        messages=[{"role": "user", "content": prompt}],
    ) as s:
        for text in s.text_stream:
            yield text

for chunk in stream("Explain async/await in Python"):
    print(chunk, end="", flush=True)

4. Strukturalne wyjście

from pydantic import BaseModel
from typing import List

class ExtractedData(BaseModel):
    entities: List[str]
    sentiment: str
    summary: str

import json

response = client.chat.completions.create(
    model="gpt-5.4",
    messages=[
        {"role": "system", "content": f"Extract data and return JSON matching this schema: {ExtractedData.schema()}"},
        {"role": "user", "content": "Apple reported record revenue. CEO Tim Cook called it exceptional."},
    ],
    response_format={"type": "json_object"},
)

data = ExtractedData(**json.loads(response.choices[0].message.content))
print(data.entities)    # ["Apple", "Tim Cook"]
print(data.sentiment)   # "positive"

5. Użycie narzędzi / wywoływanie funkcji

import json

tools = [
    {
        "type": "function",
        "function": {
            "name": "execute_sql",
            "description": "Run a read-only SQL query",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string"},
                    "database": {"type": "string", "enum": ["users", "orders", "products"]},
                },
                "required": ["query", "database"],
            },
        },
    }
]

def handle_tool_call(tool_name: str, args: dict) -> str:
    # Your implementation
    return json.dumps({"result": "mock data"})

def agent_loop(user_msg: str):
    messages = [{"role": "user", "content": user_msg}]
    
    while True:
        resp = client.chat.completions.create(
            model="gpt-5.4",
            messages=messages,
            tools=tools,
        )
        
        if resp.choices[0].finish_reason != "tool_calls":
            return resp.choices[0].message.content
        
        # Process tool calls
        messages.append(resp.choices[0].message)
        for tc in resp.choices[0].message.tool_calls:
            result = handle_tool_call(tc.function.name, json.loads(tc.function.arguments))
            messages.append({"role": "tool", "tool_call_id": tc.id, "content": result})

6. Osadzenia (embeddingi)

def embed(texts: list[str]) -> list[list[float]]:
    response = client.embeddings.create(
        model="text-embedding-3-small",
        input=texts,
    )
    return [item.embedding for item in response.data]

# Semantic similarity
import numpy as np

def cosine_similarity(a, b):
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

vecs = embed(["Python is great", "I love Python", "Java is verbose"])
print(cosine_similarity(vecs[0], vecs[1]))  # High: ~0.95
print(cosine_similarity(vecs[0], vecs[2]))  # Lower: ~0.70

7. RAG (Generacja wspomagana wyszukiwaniem)

from typing import List

def rag_query(user_question: str, knowledge_base: List[str]) -> str:
    # Step 1: Embed the question
    q_embedding = embed([user_question])[0]
    doc_embeddings = embed(knowledge_base)
    
    # Step 2: Find most relevant docs
    similarities = [cosine_similarity(q_embedding, d) for d in doc_embeddings]
    top_indices = sorted(range(len(similarities)), key=lambda i: similarities[i], reverse=True)[:3]
    context = "\n\n".join(knowledge_base[i] for i in top_indices)
    
    # Step 3: Generate answer with context
    response = client.chat.completions.create(
        model="claude-sonnet-4-6",
        messages=[
            {"role": "system", "content": f"Answer using only this context:\n\n{context}"},
            {"role": "user", "content": user_question},
        ],
    )
    return response.choices[0].message.content

8. Asynchroniczność dla wysokiej przepustowości

import asyncio
from openai import AsyncOpenAI

async_client = AsyncOpenAI(
    api_key="YOUR_APIMASTER_KEY",
    base_url="https://apimaster.ai/v1",
)

async def process_batch(prompts: list[str]) -> list[str]:
    tasks = [
        async_client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[{"role": "user", "content": p}],
            max_tokens=100,
        )
        for p in prompts
    ]
    responses = await asyncio.gather(*tasks)
    return [r.choices[0].message.content for r in responses]

# Process 50 prompts concurrently
results = asyncio.run(process_batch(my_prompts))

Lista kontrolna dla produkcji

• Klucze API w zmiennych środowiskowych, nie w kodzie źródłowym
• Logika ponawiania z wykładniczym opóźnieniem dla błędów 429/500
• Ustawione max_tokens, aby zapobiec niekontrolowanym kosztom
• Strumieniowanie dla odpowiedzi użytkownika >2 sekund
• Logowanie żądań z liczbą tokenów do śledzenia kosztów
• Ogranicznik szybkości, aby pozostać w limitach dostawcy

Wybór odpowiedniego modelu

Zastosowanie	Model	Poziom kosztów
Prototypowanie	deepseek-v4-flash lub gpt-4o-mini	Bardzo niski
Chatbot produkcyjny	claude-haiku-4-5	Niski
Asystent kodowania	deepseek-v4-flash lub claude-sonnet-4-6	Niski–średni
Złożona analiza	claude-sonnet-4-6	Średni
Badania/rozumowanie	claude-opus-4-8 lub o3	Wysoki

Często zadawane pytania

Czym jest API LLM? API LLM to interfejs HTTP, który pozwala twojemu kodowi wysyłać prompt tekstowy i otrzymywać odpowiedzi generowane przez AI. Wysyłasz tablicę messages; API zwraca uzupełnienie. Większość używa formatu OpenAI Chat Completions.

Jak wybrać między dostawcami API LLM? Rozważ możliwości modelu (benchmarki), koszt na token, opóźnienie i niezawodność. W większości przypadków DeepSeek V4 Flash (tanie kodowanie), Claude Sonnet (pisanie/analiza) lub GPT-4o (multimodalne) pokrywają typowe ścieżki. APIMaster pozwala zmienić dostawcę jedną linią.

Czym jest API zgodne z OpenAI? Punkt końcowy, który implementuje ten sam format /v1/chat/completions co OpenAI, umożliwiając użycie biblioteki openai w Pythonie lub dowolnego narzędzia zgodnego z OpenAI z modelami innych firm.

Jak obsługiwać błędy API LLM w produkcji? Łap RateLimitError (ponów z opóźnieniem), APIConnectionError (ponów) i InvalidRequestError (popraw prompt). Używaj limitów czasu i wyłączników obwodów dla odporności produkcyjnej.

Czy mogę użyć jednego klucza API dla wielu dostawców LLM? Tak — APIMaster zapewnia jeden klucz i punkt końcowy dla GPT, Claude, DeepSeek i Gemini. Zmieniaj modele, zmieniając parametr model. Nie są potrzebne klucze ani SDK specyficzne dla dostawcy.

Uzyskaj dostęp do API LLM → · Porównaj modele →