API LLM untuk Pengembang: Panduan Integrasi Lengkap

Panduan ini mencakup semua yang dibutuhkan pengembang untuk mengintegrasikan API LLM ke dalam aplikasi produksi: autentikasi, streaming, penggunaan alat, embeddings, pola RAG, dan manajemen biaya. Semua contoh menggunakan format yang kompatibel dengan OpenAI dan bekerja dengan APIMaster.ai.

Setup

from openai import OpenAI

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

Pola Inti

1. Chat Completion Dasar

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 Sistem + Percakapan

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. Streaming

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. Output Terstruktur

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. Penggunaan Alat / Pemanggilan Fungsi

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. Embeddings

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 (Retrieval-Augmented Generation)

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. Async untuk Throughput Tinggi

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))

Daftar Periksa Produksi

• Kunci API di variabel lingkungan, bukan di kode sumber
• Logika coba ulang dengan backoff eksponensial untuk error 429/500
• max_tokens diatur untuk mencegah biaya melonjak
• Streaming untuk respons yang dilihat pengguna >2 detik
• Pencatatan permintaan dengan jumlah token untuk pelacakan biaya
• Pembatas laju untuk tetap dalam batas penyedia

Memilih Model yang Tepat

Kasus Penggunaan	Model	Tingkat Biaya
Pembuatan Prototipe	deepseek-v4-flash atau gpt-4o-mini	Sangat rendah
Chatbot produksi	claude-haiku-4-5	Rendah
Asisten kode	deepseek-v4-flash atau claude-sonnet-4-6	Rendah–sedang
Analisis kompleks	claude-sonnet-4-6	Sedang
Riset/penalaran	claude-opus-4-8 atau o3	Tinggi

Pertanyaan yang Sering Diajukan

Apa itu API LLM? API LLM adalah antarmuka HTTP yang memungkinkan kode Anda mengirim prompt teks dan menerima respons yang dihasilkan AI. Anda mengirim larik messages; API mengembalikan completion. Sebagian besar menggunakan format OpenAI Chat Completions.

Bagaimana cara memilih antara penyedia API LLM? Pertimbangkan kemampuan model (benchmark), biaya per token, latensi, dan keandalan. Untuk sebagian besar kasus penggunaan, DeepSeek V4 Flash (coding biaya rendah), Claude Sonnet (menulis/analisis), atau GPT-4o (multimodal) mencakup jalur umum. APIMaster memungkinkan Anda mengganti penyedia dengan satu baris.

Apa itu API yang kompatibel dengan OpenAI? Endpoint yang mengimplementasikan format /v1/chat/completions yang sama dengan OpenAI, memungkinkan Anda menggunakan pustaka Python openai atau alat apa pun yang kompatibel dengan OpenAI dengan model non-OpenAI.

Bagaimana cara menangani error API LLM di produksi? Tangkap RateLimitError (coba ulang dengan backoff), APIConnectionError (coba ulang), dan InvalidRequestError (perbaiki prompt). Gunakan timeout dan circuit breaker untuk ketahanan produksi.

Bisakah saya menggunakan satu kunci API untuk beberapa penyedia LLM? Ya—APIMaster menyediakan satu kunci dan endpoint untuk GPT, Claude, DeepSeek, dan Gemini. Ganti model dengan mengubah parameter model. Tidak perlu kunci atau SDK khusus penyedia.

Dapatkan akses API LLM → · Bandingkan model →