Jika berhasil, Anda akan melihat daftar model yang tersedia di Groq.

Basic Usage

Chat Completion Sederhana

Penggunaan paling dasar dari Groq API adalah chat completion:

Streaming dengan Metadata

Anda bisa mengumpulkan metadata selama streaming:

Async Support

Penggunaan Async Client

Untuk aplikasi yang membutuhkan concurrency tinggi:

Menggunakan Tools dalam Chat

import base64
import httpx

def encodeimagefromurl(imageurl):

    response = httpx.get(imageurl)
    return base64.b64encode(response.content).decode("utf-8")

def encodeimagefromfile(filepath):
    with open(filepath, "rb") as f:

        return base64.b64encode(f.read()).decode("utf-8")

Analisis gambar dari URL
def analyzeimage(imageurl, question="Deskripsikan gambar ini secara detail."):

    response = client.chat.completions.create(
        messages=[
            {
                "role": "user",
                "content": [
                    {"type": "text", "text": question},
                    {
                        "type": "imageurl",
                        "imageurl": {

                            "url": imageurl,
                        },
                    },
                ],
            }
        ],
        model="llama-3.2-90b-vision-preview",
        maxtokens=1024,

    )

    return response.choices[0].message.content

Analisis gambar dari file lokal
def analyzelocalimage(filepath, question="Apa yang kamu lihat di gambar ini?"):
    base64image = encodeimagefromfile(filepath)


    response = client.chat.completions.create(
        messages=[
            {
                "role": "user",
                "content": [
                    {"type": "text", "text": question},
                    {
                        "type": "imageurl",
                        "imageurl": {

                            "url": f"data:image/png;base64,{base64image}",
                        },
                    },
                ],
            }
        ],
        model="llama-3.2-90b-vision-preview",
        maxtokens=1024,

    )

    return response.choices[0].message.content

import json

def extractentities(text):
    response = client.chat.completions.create(
        messages=[
            {
                "role": "system",
                "content": "Ekstrak entitas dari teks dan kembalikan dalam format JSON "
                           "dengan key: persons (array), locations (array), "
                           "organizations (array), dates (array)."
            },
            {"role": "user", "content": text}
        ],
        model="llama-3.3-70b-versatile",
        temperature=0,
        maxtokens=1024,

        responseformat={"type": "jsonobject"},

    )

    return json.loads(response.choices[0].message.content)

text = """
Pada tanggal 15 Januari 2026, CEO Google Sundar Pichai mengumumkan 
pembukaan kantor baru di Jakarta. Menteri Komunikasi Indonesia 
menyambut baik investasi ini.
"""

entities = extractentities(text)
print(json.dumps(entities, indent=2, ensureascii=False))

def analyzesentimentbatch(reviews):
    response = client.chat.completions.create(
        messages=[
            {
                "role": "system",
                "content": (
                    "Analisis sentimen dari setiap review. "
                    "Kembalikan JSON dengan key 'results' berisi array of objects "
                    "dengan fields: reviewindex (int), sentiment (positive/negative/neutral), "
                    "confidence (0.0-1.0), keyphrases (array of string)."

                )
            },
            {
                "role": "user",
                "content": json.dumps(reviews, ensureascii=False)
            }
        ],
        model="llama-3.3-70b-versatile",
        temperature=0,
        responseformat={"type": "jsonobject"},
        maxtokens=2048,

    )

    return json.loads(response.choices[0].message.content)

reviews = [
    "Produk sangat bagus, pengiriman cepat!",
    "Kualitas mengecewakan, tidak sesuai deskripsi.",
    "Biasa saja, sesuai harganya.",
]

results = analyzesentimentbatch(reviews)

print(json.dumps(results, indent=2, ensureascii=False))

Advanced Usage

Rate Limiting dan Retry

Implementasi retry logic yang robust:

import time
from groq import Groq, RateLimitError, APIError

def robustcompletion(messages, model="llama-3.3-70b-versatile", 

                      maxretries=3, kwargs):
    client = Groq()

    for attempt in range(maxretries):

        try:
            response = client.chat.completions.create(
                messages=messages,
                model=model,
                kwargs

            )
            return response
        except RateLimitError as e:
            if attempt < maxretries - 1:
                waittime = (2  attempt) + 1

                print(f"Rate limited. Menunggu {waittime} detik...")
                time.sleep(waittime)

            else:
                raise
        except APIError as e:
            if attempt < maxretries - 1:
                print(f"API error: {e}. Retry {attempt + 1}/{maxretries}")

                time.sleep(1)
            else:
                raise

    return None

def processlongdocument(document, chunksize=4000, overlap=200):
    chunks = []
    start = 0
    while start < len(document):
        end = start + chunksize

        chunk = document[start:end]
        chunks.append(chunk)
        start = end - overlap

    summaries = []
    for i, chunk in enumerate(chunks):
        response = client.chat.completions.create(
            messages=[
                {
                    "role": "system",
                    "content": "Ringkas bagian dokumen berikut secara padat."
                },
                {"role": "user", "content": chunk}
            ],
            model="llama-3.1-8b-instant",
            temperature=0.3,
            maxtokens=512,
        )
        summaries.append(response.choices[0].message.content)
        print(f"Chunk {i+1}/{len(chunks)} diproses.")

    # Gabungkan semua ringkasan
    combined = "\n\n".join(summaries)
    finalresponse = client.chat.completions.create(

        messages=[
            {
                "role": "system",
                "content": "Gabungkan ringkasan-ringkasan berikut menjadi "
                           "satu ringkasan yang koheren dan komprehensif."
            },
            {"role": "user", "content": combined}
        ],
        model="llama-3.3-70b-versatile",
        temperature=0.3,
        maxtokens=1024,
    )

    return finalresponse.choices[0].message.content

from langchaingroq import ChatGroq
from langchaincore.messages import HumanMessage, SystemMessage

from langchaincore.outputparsers import StrOutputParser

from langchaincore.prompts import ChatPromptTemplate

Inisialisasi model
llm = ChatGroq(
    model="llama-3.3-70b-versatile",
    temperature=0.7,
    maxtokens=1024,

)

Chain sederhana
prompt = ChatPromptTemplate.frommessages([
    ("system", "Kamu adalah ahli {topic} yang menjelaskan konsep secara sederhana."),
    ("human", "{question}")
])

chain = prompt | llm | StrOutputParser()

result = chain.invoke({
    "topic": "machine learning",
    "question": "Apa perbedaan supervised dan unsupervised learning?"
})
print(result)

Integrasi dengan LlamaIndex

from llamaindex.llms.groq import Groq as GroqLLM
from llamaindex.core.llms import ChatMessage

llm = GroqLLM(model="llama-3.3-70b-versatile", apikey=os.environ["GROQAPIKEY"])


messages = [
    ChatMessage(role="system", content="Kamu adalah asisten yang ahli dalam coding."),
    ChatMessage(role="user", content="Tulis fungsi Python untuk binary search."),
]

response = llm.chat(messages)
print(response.message.content)

from fastapi import FastAPI, HTTPException
from fastapi.responses import StreamingResponse
from pydantic import BaseModel
from groq import Groq
import json

app = FastAPI(title="Groq Chatbot API")
client = Groq()

class ChatRequest(BaseModel):
    message: str
    model: str = "llama-3.3-70b-versatile"
    systemprompt: str = "Kamu adalah asisten AI yang membantu."
    stream: bool = False
    history: list[dict] = []

@app.post("/chat")
async def chat(request: ChatRequest):
    messages = [{"role": "system", "content": request.systemprompt}]

    messages.extend(request.history)
    messages.append({"role": "user", "content": request.message})

    if request.stream:
        async def generate():
            stream = client.chat.completions.create(
                messages=messages,
                model=request.model,
                stream=True,
                maxtokens=2048,
            )
            for chunk in stream:
                content = chunk.choices[0].delta.content
                if content:
                    yield f"data: {json.dumps({'content': content})}\n\n"
            yield "data: [DONE]\n\n"

        return StreamingResponse(generate(), mediatype="text/event-stream")


    response = client.chat.completions.create(
        messages=messages,
        model=request.model,
        maxtokens=2048,
    )

    return {
        "response": response.choices[0].message.content,
        "usage": {
            "prompttokens": response.usage.prompttokens,
            "completiontokens": response.usage.completiontokens,
            "totaltokens": response.usage.totaltokens,
        }
    }

@app.get("/models")
async def listmodels():

    models = client.models.list()
    return {"models": [m.id for m in models.data]}

pip install fastapi uvicorn
uvicorn main:app --reload --port 8000

# Buruk - terlalu panjang dan ambigu
badprompt = "Tolong bantu saya menganalisis data penjualan ini dan berikan insight yang berguna tentang apa yang bisa diperbaiki..."

Baik - spesifik dan terstruktur
goodprompt = """Analisis data penjualan berikut:

Identifikasi 3 produk dengan performa terbaik
Identifikasi 3 produk dengan penurunan terbesar
Saran perbaikan untuk setiap produk yang menurun

Format output: JSON dengan key topproducts, decliningproducts, recommendations"""

import time
from collections import deque

class RateLimiter:
    def init(self, maxrequestsperminute=30):
        self.maxrpm = maxrequestsperminute
        self.requests = deque()

    def waitifneeded(self):
        now = time.time()
        # Hapus request yang lebih dari 1 menit lalu
        while self.requests and self.requests[0] < now - 60:
            self.requests.popleft()

        if len(self.requests) >= self.maxrpm:

            sleeptime = 60 - (now - self.requests[0])
            if sleeptime > 0:

                print(f"Rate limit mendekati. Menunggu {sleeptime:.1f} detik...")
                time.sleep(sleeptime)


        self.requests.append(time.time())

limiter = RateLimiter(maxrequestsperminute=30)

def safecompletion(messages, kwargs):

    limiter.waitifneeded()

    return client.chat.completions.create(messages=messages, kwargs)

import hashlib
import json

class SimpleCache:
    def init(self):
        self.cache = {}

    def makekey(self, messages, model, temperature):

        content = json.dumps({"messages": messages, "model": model, 
                             "temperature": temperature}, sortkeys=True)
        return hashlib.md5(content.encode()).hexdigest()

    def getorcreate(self, messages, model="llama-3.3-70b-versatile",
                      temperature=0, kwargs):

        key = self.makekey(messages, model, temperature)

        if key in self.cache:
            print("Cache hit!")
            return self.cache[key]

        response = client.chat.completions.create(
            messages=messages,
            model=model,
            temperature=temperature,
            kwargs
        )

        result = response.choices[0].message.content
        self.cache[key] = result
        return result

cache = SimpleCache()

5. Error Handling yang Baik

from groq import (
    Groq,
    APIError,
    AuthenticationError,
    RateLimitError,
    BadRequestError,
)

def safechat(messages, model="llama-3.3-70b-versatile"):

    try:
        response = client.chat.completions.create(
            messages=messages,
            model=model,
            maxtokens=1024,
        )
        return {
            "success": True,
            "content": response.choices[0].message.content,
            "usage": response.usage,
        }
    except AuthenticationError:
        return {"success": False, "error": "API key tidak valid."}
    except RateLimitError:
        return {"success": False, "error": "Rate limit tercapai. Coba lagi nanti."}
    except BadRequestError as e:
        return {"success": False, "error": f"Request tidak valid: {e}"}
    except APIError as e:
        return {"success": False, "error": f"API error: {e}"}

Perbandingan Groq dengan Provider Lain

| Fitur | Groq | OpenAI | Anthropic |

|-------|------|--------|-----------|

| Kecepatan Inferensi | Sangat cepat (LPU) | Standar (GPU) | Standar (GPU) |

| Model | Open-source (Llama, Mixtral) | GPT-4, GPT-4o | Claude |

| Harga | Kompetitif | Premium | Premium |

| Context Window | Hingga 128K | Hingga 128K | Hingga 200K |

| Function Calling | Ya | Ya | Ya |

| Vision | Ya (Llama Vision) | Ya (GPT-4o) | Ya (Claude) |

| Streaming | Ya | Ya | Ya |

| JSON Mode | Ya | Ya | Ya |

Conclusion

Groq API menawarkan solusi inferensi LLM yang sangat cepat dengan API yang mudah digunakan dan kompatibel dengan format OpenAI. Keunggulan utama Groq ada pada:

Dengan tutorial ini, Anda sudah memiliki fondasi yang kuat untuk membangun aplikasi AI menggunakan Groq API. Mulai dari penggunaan dasar hingga integrasi dengan framework populer dan best practices untuk produksi.

Langkah selanjutnya yang bisa Anda eksplorasi:

• Implementasi RAG (Retrieval-Augmented Generation) menggunakan Groq
• Membangun multi-agent system dengan Groq sebagai backbone
• Optimasi cost dengan model routing berdasarkan kompleksitas task
• Monitoring dan observability untuk aplikasi Groq di produksi