Groq API menjadi salah satu alternatif terbaik untuk OpenAI API yang menawarkan kecepatan inference AI super cepat dengan free tier yang generous. Tutorial ini akan membahas step-by-step untuk mengintegrasikan Groq API dengan Python, mulai dari setup hingga membuat aplikasi AI sederhana tetapi tetap powerful.

Apa Itu Groq API?

Groq API adalah layanan cloud AI yang menggunakan Groq LPU (Language Processing Unit), sebuah hardware khusus yang dirancang untuk inference AI ultra-cepat. Dibandingkan dengan GPU tradisional, Groq LPU dapat menghasilkan token dengan kecepatan hingga 10x lebih cepat. Groq menyediakan API gratis yang bisa kamu gunakan untuk berbagai kebutuhan termasuk chatbot, summarization, hingga analisis teks.

Tools atau Library Yang Diperlukan

Python 3.x
groq
requests
python-dotenv

Perisapan

Buat API Key

Kita bisa mendapatkan API Key dari Groq dengan megunjungi link berikut Groq Console.
Setelah itu buat akun dengan menggunakan akun Google dan pindah navigasi ke menu API Key pada dashboard.
Salin dan simpan API Key tersebut!

Install Library atau Dependencies

Ketikka perintah dibawah ini pada terminal kalian masing-masing:

pip install groq python-dotenv requests

Konfigurasi Environment Variable

Setelah melakukan installasi library, buat file .env pada root direktori project dan pastekan kode dibawah ini.

GROQ_API_KEY=your_api_key

Note: ubah your_api_key menjadi API Key yang kita dapatkan dari Groq Console.

Implementasi

Load ENV

Buat file config.py, lalu pastekan kode dibawah ini.

import os
from dotenv import load_dotenv

load_dotenv()

GROQ_API_KEY = os.getenv('GROQ_API_KEY')

if not GROQ_API_KEY:
    raise ValueError("GROQ_API_KEY not found in environment variables")

AVAILABLE_MODELS = {
    'openai': 'openai/gpt-oss-120b',
}

DEFAULT_MODEL = AVAILABLE_MODELS['openai']

File config.py bertugas untuk mengambil API Key dari file .env sekaligus melakukan handling error jika variable GROQ_API_KEY tidak ditemukan.

Test & Setup Connection

Sebelum membuat Chat Bot kita perlu melakukan uji coba koneksi dengan API dari Groq terlebih dahulu. Buat file test_groq.py.

from groq import Groq
from config import GROQ_API_KEY, DEFAULT_MODEL

def setup_groq():
    try:
        client = Groq(api_key=GROQ_API_KEY)
        
        print("🔄 Testing Groq API connection...")
        
        chat_completion = client.chat.completions.create(
            messages=[
                {
                    "role": "user",
                    "content": "Say hello in Japanese!"
                }
            ],
            model=DEFAULT_MODEL,
            max_tokens=50,
            temperature=0.7
        )
        
        # Extract response
        response = chat_completion.choices[0].message.content
        
        print("✅ Connection Successfully!")
        print(f"🤖 Response: {response}")
        print(f"📊 Model used: {DEFAULT_MODEL}")
        
        return True
        
    except Exception as e:
        print(f"❌ Error: {e}")
        return False

if __name__ == "__main__":
    success = setup_groq()
    
    if success:
        print("\n🎉 Setup successful! Ready for development.")
    else:
        print("\n🔧 Check your API key and internet connection.")

Penjelasan beberapa parameter dan function dari kode diatas:

Groq(api_key=GROQ_API_KEY) inisialisasi client.
client.chat.completions.create() mengirim konfigurasi ke client.
messages Array berisi conversation history.
model Model AI yang akan digunakan.
max_tokens Batas maksimal token output.

Setelah itu buka terminal dan jalankan file tersebut dengan perintah dibawah.

python test_groq.py

Jika koneksi berhasil, maka akan menampilkan output seperti ini pada terminal. Test Connection Groq API & Python - NganggurDev

Membuat Chatbot

Sekarang kita bisa membuat Chat Bot dengan fitur yang bisa menyimpan histori percakapan, memberi jawaban, hingga menyimpan percakapan kedalam file berformat JSON. Buat file chatbot.py dan pastekan kode dibawah ini.

from groq import Groq
from config import GROQ_API_KEY, DEFAULT_MODEL
import json
from datetime import datetime

class GroqChatbot:
    def __init__(self, model=DEFAULT_MODEL):
        self.client = Groq(api_key=GROQ_API_KEY)
        self.model = model
        self.conversation_history = []
        self.total_tokens_used = 0
        
        print(f"🤖 Chatbot initialized with model: {model}")
    
    def add_message(self, role, content):
        message = {
            "role": role,
            "content": content,
            "timestamp": datetime.now().isoformat()
        }
        self.conversation_history.append(message)

        if len(self.conversation_history) > 20:
            system_messages = [msg for msg in self.conversation_history if msg["role"] == "system"]
            recent_messages = [msg for msg in self.conversation_history if msg["role"] != "system"][-18:]
            self.conversation_history = system_messages + recent_messages
    
    def set_system_prompt(self, system_message):
        self.conversation_history = [msg for msg in self.conversation_history 
                                   if msg["role"] != "system"]
        
        self.conversation_history.insert(0, {
            "role": "system",
            "content": system_message,
            "timestamp": datetime.now().isoformat()
        })
    
    def get_response(self, user_message):
        try:
            self.add_message("user", user_message)
            
            api_messages = [
                {"role": msg["role"], "content": msg["content"]} 
                for msg in self.conversation_history
            ]
            
            chat_completion = self.client.chat.completions.create(
                messages=api_messages,
                model=self.model,
                max_tokens=200,      
                temperature=0.7,
                top_p=0.9,
                stream=False
            )
            
            ai_response = chat_completion.choices[0].message.content
            
            if hasattr(chat_completion, 'usage'):
                self.total_tokens_used += chat_completion.usage.total_tokens
            
            self.add_message("assistant", ai_response)
            
            return ai_response
            
        except Exception as e:
            error_message = f"Error: {str(e)}"
            print(f"❌ {error_message}")
            return error_message
    
    def save_conversation(self, filename=None):
        if not filename:
            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
            filename = f"conversation_{timestamp}.json"
        
        try:
            with open(filename, 'w', encoding='utf-8') as f:
                json.dump({
                    "model": self.model,
                    "total_tokens": self.total_tokens_used,
                    "conversation": self.conversation_history
                }, f, indent=2, ensure_ascii=False)
            
            print(f"💾 Conversation saved to {filename}")
            
        except Exception as e:
            print(f"❌ Error saving conversation: {e}")
    
    def get_stats(self):
        return {
            "total_messages": len(self.conversation_history),
            "total_tokens_used": self.total_tokens_used,
            "model": self.model
        }

if __name__ == "__main__":
    bot = GroqChatbot()
    
    bot.set_system_prompt(
        "You are a helpful and friendly AI assistant."
        "Answer in natural and easy-to-understand."
        "If you don't know the answer, say so honestly."
    )

    print("🚀 Groq Chatbot is ready to use!")
    print("💬 Type your message (type 'quit' to exit, 'save' to save)")
    print("=" * 60)
    
    while True:
        user_input = input("\n👤 You: ").strip()
        
        if user_input.lower() == 'quit':
            print("👋 See you next time!")
            break
        elif user_input.lower() == 'save':
            bot.save_conversation()
            continue
        elif user_input.lower() == 'stats':
            stats = bot.get_stats()
            print(f"📊 Stats: {stats}")
            continue
        elif not user_input:
            continue
        
        print("🤖 Bot:", end=" ")
        response = bot.get_response(user_input)
        print(response)
        print("-" * 60)

Penjelasan fitur utama pada Chat Bot:

Memory Management: Chatbot menyimpan riwayat percakapan dengan batasan untuk menghemat token.
System Prompt: Bisa mengatur personality dan instruksi khusus untuk AI.
Token Tracking: Memantau penggunaan token untuk budget control.
Conversation Export: Menyimpan percakapan ke file JSON.
Error Handling: Robust error handling untuk production use.

Setelah itu, buka terminal dan jalankan file chatbot.py dengan perintah dibawah ini.

python chatbot.py

Demo Chatbot Groq API dengan Python

Demo Chatbot Groq AI with Python - NganggurDev Save Command Stats Command

Kesimpulan

Dengan mengikuti tutorial ini, kita berhasil membuat Chatbot AI super cepat menggunakan Groq API pada Python.

Terimakasih.