# Integrasi AI

> Integrasikan 2328.io ke dalam aplikasi Anda dalam hitungan menit menggunakan asisten AI seperti Claude, ChatGPT, Cursor, dan GitHub Copilot.

Dokumentasi 2328.io dirancang agar **ramah-LLM**. Anda dapat memberikan seluruh referensi API kepada asisten AI modern apa pun dan mendapatkan integrasi yang berfungsi dalam bahasa pilihan Anda — PHP, Node.js, Python, Go, Rust — dalam hitungan menit alih-alih jam.

Halaman ini menjelaskan cara melakukannya secara efisien.

## Mengapa menggunakan AI untuk integrasi

- **Onboarding lebih cepat** — lewati boilerplate, langsung ke logika bisnis
- **Penandatanganan yang benar** — AI dengan andal mereproduksi penandatanganan HMAC-SHA256 dalam bahasa apa pun
- **Handler webhook** — buat verifikasi tanda tangan dan handler idempoten secara langsung
- **Selalu terbaru** — `llms-full.txt` kami diregenerasi pada setiap pembaruan dokumentasi, jadi Anda selalu mendapatkan skema terkini

## Dokumentasi yang dapat dibaca mesin

Kami menerbitkan tiga endpoint mengikuti standar [llmstxt.org](https://llmstxt.org):

| Endpoint | Tujuan |
|----------|---------|
| [`/llms.txt`](https://doc.2328.io/llms.txt) | Indeks pendek dari semua dokumen dengan tautan |
| [`/llms-full.txt`](https://doc.2328.io/llms-full.txt) | Dokumentasi lengkap sebagai file tunggal — tempel ke obrolan AI Anda |
| [`/md/{locale}/{slug}`](https://doc.2328.io/md/en/payments) | Halaman apa pun sebagai Markdown mentah |

Setiap halaman HTML juga menampilkan `<link rel="alternate" type="text/markdown">` yang menunjuk ke versi Markdown-nya, jadi crawler AI menemukannya secara otomatis.

## Dokumentasi server MCP

Agen AI yang mendukung [Model Context Protocol](https://modelcontextprotocol.io) dapat terhubung langsung ke:

```
https://doc.2328.io/mcp
```

Endpoint ini bersifat publik, hanya-baca, dan tidak memerlukan kunci API pedagang. Ini hanya menyajikan pengetahuan dokumentasi; tidak dapat memeriksa saldo, membuat pembayaran, atau memindahkan dana.

Konfigurasi remote-MCP umum:

```json
{
  "mcpServers": {
    "2328-docs": {
      "url": "https://doc.2328.io/mcp"
    }
  }
}
```

Sintaks konfigurasi yang tepat bervariasi tergantung pada klien MCP. Gunakan HTTP Streamable dan arahkan klien ke URL di atas.

### Alat MCP

| Alat | Kapan agen harus menggunakannya |
|------|------------------------------|
| `list_docs` | Menemukan semua topik dokumentasi dan URI sumber daya. |
| `search_docs` | Temukan jawaban tingkat seksi dengan kutipan yang diberi peringkat dan tautan sumber langsung. |
| `get_doc` | Baca versi portable-Markdown lengkap dari satu halaman. |
| `get_integration_guide` | Buat rencana terpandu untuk checkout yang dihosting, H2H, faktur kripto tepat, dompet statis, konversi otomatis, konversi manual, atau pembayaran. |

Semua hasil alat menyertakan JSON terstruktur serta teks yang dapat dibaca manusia. Hasil pencarian mengembalikan item `resource_link` sehingga agen dapat mengambil hanya halaman yang mereka butuhkan daripada memuat seluruh korpus.

### Sumber MCP

| Sumber | Tujuan |
|----------|---------|
| `docs://2328/index` | Indeks layanan dan dokumen yang dapat dibaca mesin. |
| `docs://2328/en/full` | Referensi integrasi bahasa Inggris lengkap dengan potongan kode bersama yang diperluas. |
| `docs://2328/{locale}/{slug}` | Satu halaman yang dilokalkan; terjemahan yang hilang akan kembali ke bahasa Inggris. |

Template sumber daya mendukung penyelesaian locale dan slug, yang memungkinkan klien yang kompatibel menemukan URI yang valid tanpa menebak-nebak.

### MCP memicu

- `integrate-2328` memberitahu agen untuk membaca panduan yang benar dan menghasilkan kode implementasi, pengujian, konfigurasi, dan daftar periksa go-live.
- `review-2328-integration` meminta agen untuk meninjau kode yang ada untuk penandatanganan, ruang lingkup tenant/proyek, penanganan desimal, idempoten, pengurutan webhook, timeout ambigu, dan celah rekonsiliasi.

### Alur kerja agen yang disarankan

1. Gunakan `get_integration_guide` untuk pola integrasi yang dipilih.
2. Baca setiap halaman yang terhubung dengan sumber daya MCP atau `get_doc`.
3. Gunakan `search_docs` untuk pertanyaan spesifik framework atau kasus tepi.
4. Lakukan pengujian tanda tangan dan webhook sebelum panggilan API.
5. Tinjau hasil dengan `review-2328-integration`.
6. Uji transaksi nyata kecil di lingkungan terkendali; akses dokumentasi MCP tidak membuktikan konektivitas API produksi.

> **WARNING:** Dokumentasi MCP adalah sumber pengetahuan integrasi, bukan dompet MCP. Jangan pernah menempelkan kunci API, kunci pembayaran, rahasia webhook, data pribadi pelanggan, atau payload produksi ke argumen atau prompt alat.

## Mulai cepat dengan Claude atau ChatGPT

### Langkah 1 — Sediakan dokumentasi

Buka obrolan baru dan tempel konten [`llms-full.txt`](https://doc.2328.io/llms-full.txt) sebagai pesan pertama Anda, atau bagikan tautan saja jika modelnya bisa mengambilnya.

### Langkah 2 — Jelaskan stack Anda

Beri tahu asisten apa yang sedang Anda bangun:

```
I'm building a Laravel 11 application. I need to:
1. Create a payment for an order (amount in USD, user pays in USDT TRC20)
2. Handle the webhook and credit the user's balance
3. Store payment records in a `payments` table

Use the 2328.io API above. Include HMAC signing, webhook signature
verification, and idempotency.
```

### Langkah 3 — Tinjau dan uji

Asisten akan menghasilkan controller, kelas service, dan handler webhook. Sebelum dirilis:

- Verifikasi bahwa `apiSign()` mengencode body sebagai Base64 **sebelum** HMAC-SHA256
- Periksa bahwa handler webhook memanggil `hash_equals()` (bukan `===`) untuk membandingkan tanda tangan
- Pastikan handler bersifat idempoten — periksa `order_id` / `txid` sebelum mengkreditkan
- Uji dengan pembayaran nyata kecil di lingkungan dev terlebih dahulu

> **WARNING:** Jangan pernah merilis kode pembayaran yang dihasilkan AI tanpa meninjau logika penandatanganan dan verifikasi webhook. Ini adalah batas keamanan kritis.

## Integrasi IDE

### Cursor

Tambahkan dokumentasi sebagai sumber dokumen kustom di pengaturan Cursor:

```
Settings → Features → Docs → Add new doc
URL: https://doc.2328.io
```

Lalu di obrolan, awali pertanyaan Anda dengan `@2328.io`:

```
@2328.io generate a webhook handler in Next.js App Router
with signature verification and idempotent credit logic
```

### GitHub Copilot

Copilot Chat dapat membaca `llms-full.txt` secara langsung:

```
#fetch https://doc.2328.io/llms-full.txt

Using the 2328.io API docs above, implement a payout endpoint
in Express that withdraws USDT BEP20 to a user-supplied address.
```

### Windsurf / Continue / asisten lainnya

Asisten apa pun yang mendukung konteks URL atau lampiran file bekerja dengan cara yang sama — lampirkan `llms-full.txt` dan jelaskan tujuan Anda.

## Claude API (Agent SDK)

Jika Anda membangun agen atau chatbot Anda sendiri yang perlu berinteraksi dengan 2328.io, suntikkan dokumentasi sekali ke dalam system prompt:

```python
from anthropic import Anthropic
import urllib.request

docs = urllib.request.urlopen(
    "https://doc.2328.io/llms-full.txt"
).read().decode()

client = Anthropic()

response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=4096,
    system=f"""You are an integration assistant for 2328.io.
Use the API reference below to answer questions and generate code.

<docs>
{docs}
</docs>""",
    messages=[
        {"role": "user", "content": "Write a Python function that creates a USDT payment"}
    ],
)

print(response.content[0].text)
```

> **INFO:** File dokumentasi lengkap berukuran ~15 KB — jauh di bawah batas konteks model modern mana pun. Anda dapat menyimpannya di sisi Anda dan menyegarkannya sekali sehari.

## Contoh prompt yang bekerja dengan baik

Salin ini ke Claude, ChatGPT, atau IDE AI Anda setelah membagikan `llms-full.txt`:

**Integrasi backend lengkap:**
```
Build a Node.js + Express service that exposes two routes:
- POST /checkout → creates a 2328.io payment and returns the payment URL
- POST /webhook/2328 → verifies the signature and marks the order as paid
Use TypeScript, Zod for validation, and a simple in-memory store.
```

**Tool penarikan:**
```
Write a CLI in Go that takes a currency, network, amount, and address
and creates a payout via the 2328.io Payout API. Use a separate payout
API key from env. Poll the status endpoint until the payout is completed.
```

**Dompet statis untuk deposit pengguna:**
```
I have a Django app where users deposit USDT TRC20 to top up their balance.
Each user should have a permanent deposit address. Implement this using
2328.io static wallets, including the webhook handler that credits their
balance when a deposit arrives.
```

## Praktik terbaik untuk integrasi berbantuan AI

- **Mulai dari `llms-full.txt`** — dirancang untuk konteks LLM, tanpa boilerplate
- **Spesifik tentang stack Anda** — framework, versi bahasa, ORM
- **Minta tes** — AI baik dalam menghasilkan unit test untuk logika penandatanganan
- **Periksa ulang penanganan kesalahan** — AI terkadang melewatkan jalur kegagalan
- **Tinjau kode tanda tangan secara manual** — ini adalah satu-satunya bagian yang *harus* benar persis
- **Segarkan secara berkala** — jika API kami berubah, ambil ulang `llms-full.txt` dan prompt ulang