Cara mengintegrasikan LlamaIndex dengan CometAPI

CometAPI
AnnaSep 10, 2025
Cara mengintegrasikan LlamaIndex dengan CometAPI

CometAPI menyediakan satu gateway tunggal yang kompatibel dengan OpenAI untuk banyak model (keluarga GPT, Anthropic/Claude, Google Gemini, dan lainnya). LlamaIndex ("kerangka kerja data" untuk membangun aplikasi LLM yang ditingkatkan dengan pengambilan data) kini menampilkan integrasi LLM CometAPI asli — artinya Anda dapat **memanggil model apa pun melalui CometAPI dari LlamaIndex.

LlamaIndex (kerangka data untuk membangun asisten pengetahuan) sekarang secara resmi mendukung API Komet sebagai backend LLM. Panduan ini menunjukkan alasan Anda memasangkannya, cara menyiapkan lingkungan, integrasi langkah demi langkah (dengan kode), kasus penggunaan RAG yang konkret, dan kiat untuk meningkatkan keandalan, biaya, dan observabilitas. Contoh-contoh berikut Dokumen LlamaIndex dan Contoh integrasi CometAPI.

Apa itu LlamaIndex dan apa saja fitur utamanya?

LlamaIndex (sebelumnya GPT-Index) adalah kerangka kerja abstraksi dan pengambilan data yang menghubungkan model bahasa besar (LLM) ke data Anda sendiri dengan menyerap dokumen, membangun indeks, dan mengorkestrasi alur kerja pengambilan + prompt untuk aplikasi bergaya RAG. Fitur-fitur utamanya meliputi konektor penyerapan dokumen (PDF, web, basis data), indeks vektor/kata kunci/grafik, mesin kueri yang fleksibel, dan lapisan abstraksi untuk bertukar penyedia LLM. LlamaIndex dirancang untuk memungkinkan Anda "membawa data Anda sendiri" ke LLM apa pun dan membangun alur kerja untuk pemotongan dokumen, penyematan, pengambilan, dan orkestrasi prompt.

Apa saja fitur utamanya?

  • Konektor data: menyerap dari file, basis data, dan banyak sumber SaaS.
  • Primitif pengindeksan: indeks penyimpanan vektor, indeks pohon/grafik, dan jalur pengambilan.
  • Mesin kueri: orkestrasi kueri yang fleksibel (pengubahan peringkat, sintesis respons, perintah multi-langkah).
  • Adaptor LLM: backend LLM yang dapat dicolokkan — OpenAI, Anthropic, Vertex, dan sekarang CometAPI antara lain.
  • Observabilitas & panggilan balik: kait untuk melacak dan memantau panggilan LLM.

Apa itu CometAPI dan mengapa menggunakannya dengan LlamaIndex?

Apa itu CometAPI?

CometAPI adalah gerbang API yang mengekspos ratusan model AI pihak ketiga (LLM, generator gambar/video, dan embedding) di balik satu antarmuka REST yang kompatibel dengan OpenAI. Alih-alih menggunakan SDK dan kunci yang berbeda untuk setiap vendor model, Anda memanggil URL dasar CometAPI dan memilih nama model di badan permintaan — misalnya gpt, claude, gemini, atau berbagai mesin embed/gambar khusus. Pendekatan "satu API untuk 500+ model" ini mempercepat eksperimen dan mengurangi overhead operasional.

Mengapa memasangkan CometAPI dengan LlamaIndex?

LlamaIndex adalah kerangka kerja data yang mengubah dokumen Anda menjadi indeks (vektor dan lainnya) dan menggunakan LLM untuk sintesis jawaban akhir. Karena CometAPI menggunakan API bergaya OpenAI, LlamaIndex dapat:

  • Gunakan itu built-in CometAPI Integrasi LLM (disarankan), atau
  • Gunakan LLM OpenAI/“OpenAI-compatible” dan adapter embedding dengan mengarahkan api_base ke CometAPI.

LlamaIndex sudah menyediakan layanan khusus CometAPI Pembungkus dan contoh LLM — sehingga integrasinya sengaja dibuat mudah.

Apa manfaat yang diberikan integrasi?

  1. RAG + pilihan model yang fleksibel — LlamaIndex menangani pengambilan data dan sintesis perintah; CometAPI memungkinkan Anda memilih LLM yang Anda panggil tanpa harus merancang ulang alur kerja Anda.
  2. Optimalisasi biaya/latensi — cobalah model yang lebih murah atau lebih cepat untuk pertanyaan rutin dan model berkualitas lebih tinggi untuk penalaran yang berat.
  3. Portabilitas vendor — tukar penyedia model dengan hanya mengubah nama model atau konfigurasi klien kecil.
  4. Eksperimen cepat — dengan mudah membuat model A/B sambil menjaga jalur pengindeksan dan pengambilan data tetap konstan.

Apa saja prasyarat dan pengaturan lingkungan?

Akun & kunci

Daftar ke CometAPI dan dapatkan kunci API dari konsol CometAPI: https://api.cometapi.com/console/token(Anda memerlukan nilai ini untuk mengautentikasi permintaan.)

Python dan paket

  • Python 3.9+ direkomendasikan.
  • Lingkungan Jupyter Notebook atau Python (Google Colab direkomendasikan untuk pengujian interaktif).
  • Paket yang harus diinstal: llama-index (inti) dan llama-index-llms-cometapi (adaptor / integrasi CometAPI)
  • Opsional: pustaka penyimpanan vektor yang ingin Anda gunakan (misalnya, faiss-cpu, pinecone-client, dll.). LlamaIndex memiliki panduan toko resmi/vektor.

Variabel lingkungan

Praktik umum: tetapkan kunci CometAPI sebagai variabel env (misalnya COMETAPI_KEY), atau meneruskan kunci langsung ke konstruktor LlamaIndex CometAPI. Dokumen LlamaIndex menunjukkan kedua pendekatan — untuk menghindari ambiguitas dan pengujian, meneruskan api_key= secara eksplisit ke konstruktor adalah yang paling aman.

Bagaimana Anda mengintegrasikan LlamaIndex dan CometAPI langkah demi langkah?

Daftar langkah demi langkah berikut mencakup tindakan yang tepat: membuat akun, menginstal paket, mengatur kunci, mengonfigurasi LlamaIndex untuk menggunakan CometAPI.

1) Bagaimana cara membuat akun CometAPI dan mendapatkan kunci API?

  1. Kunjungi situs CometAPI dan daftar akun. (Halaman beranda dan alur pendaftaran mereka akan mengarahkan Anda ke konsol API.)
  2. Di konsol CometAPI (referensi dokumen https://api.cometapi.com/console/token), buat atau salin token API Anda. Anda akan membutuhkannya untuk COMETAPI_API_KEY (Lihat di bawah).

2) Bagaimana cara menginstal LlamaIndex dan integrasi CometAPI?

Jalankan perintah pip ini (disarankan di dalam lingkungan virtual):

# core LlamaIndex

pip install llama-index

# CometAPI LLM integration for LlamaIndex

pip install llama-index-llms-cometapi

# optional: vectorstore (FAISS example)

pip install faiss-cpu

(If you're in a Jupyter/Colab environment you can prefix with `%pip`.)

Catatan:

  • LlamaIndex menggunakan paket integrasi namespace untuk menghindari pengiriman semua yang ada di inti. Integrasi LLM CometAPI disediakan sebagai llama-index-llms-cometapi.

3) Bagaimana cara menetapkan kunci CometAPI (variabel lingkungan)?

Kelas LLM CometAPI LlamaIndex membaca kunci API dari parameter konstruktor atau variabel lingkungan. Kode integrasi mengharapkan nama variabel lingkungan COMETAPI_API_KEY (Anda juga dapat meneruskan kunci langsung ke konstruktor kelas). Ini juga mendukung COMETAPI_API_BASE jika Anda harus mengganti URL dasar API.

Direkomendasikan (eksplisit) — meneruskan kunci API ke konstruktorAnda juga dapat mengatur variabel lingkungan COMETAPI_KEY jika kamu memilih.

import os
# Option A: set env var (optional)

os.environ = "sk-xxxx-your-key"

# Option B: pass the key explicitly (recommended for clarity)

api_key = os.getenv("COMETAPI_KEY", "sk-xxxx-your-key")

Atur secara lokal (Unix/macOS):

export COMETAPI_API_KEY="sk-<your-cometapi-key>"
# optional override:

export COMETAPI_API_BASE="https://www.cometapi.com/console/"

Di Windows (PowerShell):

$env:COMETAPI_API_KEY = "sk-<your-cometapi-key>"

4) Konfigurasikan LlamaIndex untuk menggunakan CometAPI

Berikut adalah contoh minimal dari ujung ke ujung: memproses dokumen, membuat indeks vektor, dan mengeluarkan kueri. Contoh ini menggunakan API LlamaIndex modern (Contoh A: ServiceContext + indeks vektor); sesuaikan nama jika Anda menggunakan rilis LlamaIndex yang lebih lama/baru.

minimal RAG example using CometAPI as the LLM backend
from llama_index import SimpleDirectoryReader, VectorStoreIndex, ServiceContext
from llama_index.llms.cometapi import CometAPI
from llama_index.core.llms import ChatMessage

# 1) API key and LLM client

api_key = "sk-xxxx-your-key"  # or read from env

llm = CometAPI(
    api_key=api_key,
    model="gpt-4o-mini",      # pick a CometAPI-supported model

    max_tokens=512,
    context_window=4096,
)

# 2) Optional: wrap in ServiceContext (customize prompt settings, embedding model etc)

service_context = ServiceContext.from_defaults(llm=llm)

# 3) Load documents (assumes a ./data directory with files)

documents = SimpleDirectoryReader("data").load_data()

# 4) Build a vector index (FAISS, default vector store)

index = VectorStoreIndex.from_documents(documents, service_context=service_context)

# 5) Query the index

query_engine = index.as_query_engine()
resp = query_engine.query("Summarize the main points in the documents.")
print(resp)
  • Nama model dan kapabilitas yang tersedia bergantung pada CometAPI — periksa dokumen CometAPI untuk memilih model terbaik untuk kasus penggunaan Anda. Adaptor Comet LlamaIndex mendukung mode obrolan, penyelesaian, dan streaming.
  • Jika Anda ingin tanggapan streaming, Anda dapat menelepon llm.stream_chat() atau gunakan stream_complete varian yang ditunjukkan dalam dokumen.

Catatan: tergantung pada versi LlamaIndex Anda, API yang tepat untuk as_query_engine menerima llm argumen mungkin berbeda. Jika versi Anda tidak menerima lServiceContext di sini, lihat LLM di bawah. LLM CometAPI diimplementasikan sebagai CometAPI in llama_index.llms.cometapi.

Contoh B — Penggunaan CometAPI LLM secara minimal dan langsung (disarankan untuk kejelasan)

import os
from llama_index.llms.cometapi import CometAPI
from llama_index import VectorStoreIndex, SimpleDirectoryReader

# ensure env var set, or pass api_key explicitly

os.environ = "sk-<your-key>"  # or set externally

api_key = os.getenv("COMETAPI_API_KEY")
llm = CometAPI(
    api_key=api_key,          # or pass None to use env var

    model="gpt-4o-mini",      # change model string as required

    max_tokens=256,
    context_window=4096,
)

# build a simple index (local documents)

documents = SimpleDirectoryReader("data/").load_data()
index = VectorStoreIndex.from_documents(documents)

# get a query engine that uses the default llm (you can often pass llm to the query method)

query_engine = index.as_query_engine(llm=llm)   # some LlamaIndex versions accept llm here

response = query_engine.query("Summarize the key points of the corpus.")
print(response)

Bagaimana cara menggunakan fitur CometAPI dari LlamaIndex? (contoh lanjutan)

1) Panggilan chat dengan Daftar ChatMessage

Contoh:

# Initialize LLM

llm = CometLLM(
    api_key=api_key,
    max_tokens=256,
    context_window=4096,
    model="gpt-5-chat-latest",
)

# Chat call using ChatMessage

from llama_index.core.llms import ChatMessage

messages = [
    ChatMessage(role="system", content="You are a helpful assistant"),
    ChatMessage(role="user", content="Say 'Hi' only!"),
]
resp = llm.chat(messages)
print(resp)

# Use complete method

resp = llm.complete("Who is Kaiming He")
print(resp)

Keluaran yang diharapkan:

  • Respons obrolan: misalnya, assistant: Hi
  • Respons pelengkapan: misalnya, deskripsi teks tentang Kaiming He, termasuk informasi tentang ResNet.

Ini mereproduksi semantik obrolan (peran sistem/pengguna/asisten) dan seringkali menghasilkan keluaran yang lebih terkendali. Ini mengirimkan pesan sederhana dan mengambil respons model. Anda dapat menyesuaikan pesan untuk interaksi yang lebih kompleks.

Apakah CometAPI mendukung streaming?

Ya — CometAPI mendukung streaming obrolan/penyelesaian dan LlamaIndex mengekspos metode streaming pada pembungkus LLM-nya (stream_chat, stream_complete, streamable pola). Untuk aplikasi waktu nyata, gunakan metode stream_chat atau stream_complete untuk streaming respons. Contoh:

# Streaming chat

message = ChatMessage(role="user", content="Tell me what ResNet is")
resp = llm.stream_chat()
for r in resp:
    print(r.delta, end="")

# Streaming completion

resp = llm.stream_complete("Tell me about Large Language Models")
for r in resp:
    print(r.delta, end="")

Output yang Diharapkan: Streaming konten tanggapan cetak, misalnya, penjelasan tentang ResNet atau ikhtisar model bahasa besar, yang muncul dalam potongan-potongan.

Penjelasan: stream_chat dan stream_complete menghasilkan respons potongan demi potongan, cocok untuk keluaran waktu nyata. Jika terjadi kesalahan, kesalahan tersebut akan ditampilkan di konsol.

Ini mencerminkan contoh LlamaIndex untuk LLM lain yang kompatibel dengan OpenAI dan berfungsi dengan titik akhir streaming Comet. Tangani tekanan balik dan kesalahan jaringan dengan logika coba ulang/batas waktu yang kuat dalam produksi.

Beralih model dengan cepat

# try Claude from CometAPI

claude_llm = CometAPI(api_key=api_key, model="claude-3-7-sonnet-latest", max_tokens=300)
svc = ServiceContext.from_defaults(llm=claude_llm)
index = VectorStoreIndex.from_documents(documents, service_context=svc)
print(index.as_query_engine().query("Explain in one paragraph."))

Karena CometAPI menormalkan titik akhir, perubahan model hanya merupakan perubahan konstruktor — tidak diperlukan penulisan ulang jalur prompt.

Tips dan teknik peningkatan

Cara mengelola biaya dan token

  • Gunakan pengambilan: kirim hanya konteks yang diambil, bukan seluruh korpus.
  • Bereksperimenlah dengan model yang lebih kecil untuk pengambilan/peringkasan dan model yang lebih besar untuk sintesis jawaban akhir. CometAPI membuat pertukaran model menjadi mudah.

Keandalan dan pembatasan kecepatan

  • Implementasi VE coba lagi + mundur untuk kesalahan sementara.
  • Patuhi batas kecepatan CometAPI dan terapkan anggaran token per permintaan. Lacak max_tokens dalam konstruktor.

Observabilitas & debugging

  • Gunakan pengelola panggilan balik LlamaIndex untuk merekam perintah, respons, dan penggunaan token. Hubungkan log tersebut ke alur pemantauan Anda. Dokumen LlamaIndex mencakup pola observabilitas dan integrasi.

Caching dan latensi

  • Cache keluaran LLM untuk pertanyaan berulang atau perintah deterministik (misalnya, ringkasan standar).
  • Pertimbangkan untuk menggunakan model yang kecil dan cepat untuk tahap pertama dan tingkatkan ke model yang berbiaya lebih tinggi hanya bila diperlukan.

Security

  • Simpan kunci CometAPI di tempat penyimpanan rahasia (rahasia Vault/cloud) — jangan melakukan hard-code dalam kode.
  • Jika datanya sensitif, pastikan paket atau model CometAPI pilihan Anda memenuhi persyaratan kepatuhan.

Daftar periksa pemecahan masalah

  • Variabel lingkungan salah:Jika LlamaIndex tidak dapat menemukan kunci, teruskan api_key= dalam CometAPI() konstruktor menjadi eksplisit. (Dokumen menunjukkan opsi env var dan konstruktor.)
  • Model tidak didukung: Konfirmasikan nama model dengan daftar model CometAPI — tidak setiap nama ada di setiap akun.
  • Kesalahan pengindeksan: Pastikan dokumen diurai dengan benar (pengodean, tipe file). Gunakan SimpleDirectoryReader untuk pengambilan tes yang cepat.
  • Penyimpangan versiLlamaIndex sedang aktif berkembang (ServiceContext → Migrasi pengaturan). Jika ada contoh yang gagal, periksa dokumen dan panduan migrasi untuk versi yang telah Anda instal.

Mulai

CometAPI adalah platform API terpadu yang menggabungkan lebih dari 500 model AI dari penyedia terkemuka—seperti seri GPT OpenAI, Gemini Google, Claude Anthropic, Midjourney, Suno, dan lainnya—menjadi satu antarmuka yang ramah bagi pengembang. Dengan menawarkan autentikasi yang konsisten, pemformatan permintaan, dan penanganan respons, CometAPI secara drastis menyederhanakan integrasi kapabilitas AI ke dalam aplikasi Anda. Baik Anda sedang membangun chatbot, generator gambar, komposer musik, atau alur kerja analitik berbasis data, CometAPI memungkinkan Anda melakukan iterasi lebih cepat, mengendalikan biaya, dan tetap tidak bergantung pada vendor—semuanya sambil memanfaatkan terobosan terbaru di seluruh ekosistem AI.

Untuk memulai, jelajahi kemampuan model di tempat bermain dan konsultasikan Indeks Llama untuk petunjuk terperinci. Sebelum mengakses, pastikan Anda telah masuk ke CometAPI dan memperoleh kunci API. API Komet menawarkan harga yang jauh lebih rendah dari harga resmi untuk membantu Anda berintegrasi.

Siap untuk berangkat?→ Daftar ke CometAPI hari ini !

Pertanyaan Umum (FAQ)

Bagaimana cara men-debug latensi atau jeda streaming?

  • Gunakan tangkapan jaringan lokal (atau masuk ke klien HTTP Anda) untuk memeriksa bingkai streaming.
  • Cobalah model yang lebih sederhana untuk mengonfirmasi bahwa jalur jaringan/SDK, bukan model itu sendiri, yang menjadi hambatan.

Model mana yang harus saya pilih?

  • Gunakan model obrolan yang lebih kecil/murah (misalnya, gpt-4o-mini, o4-mini, atau model kompak khusus vendor) untuk QPS tinggi atau jawaban singkat.
  • Cadangkan model multimoda/rantai pemikiran yang besar untuk tugas-tugas penalaran yang mahal.
  • Latensi dan biaya patokan: salah satu manfaat CometAPI adalah mengganti model di jalur kode yang sama — mencoba beberapa model dengan cepat.

Penyimpanan indeks & vektor mana yang harus saya pilih?

  • FAISS untuk kecepatan on-prem/single-node.
  • Kerucut pinus / Weaviate untuk skala terkelola dan ketersediaan multi-wilayah (LlamaIndex mendukung banyak penyimpanan vektor melalui integrasi). Pilih berdasarkan skala dan latensi.
Baca Selengkapnya

500+ Model dalam Satu API

Diskon hingga 20%