Sağlayıcılar

kodine'da dilediğiniz LLM sağlayıcısını kullanın.

kodine, AI SDK ve Models.dev altyapısından yararlanarak 75’ten fazla LLM sağlayıcısıyla çalışır; yerel modelleri kullanmak da mümkündür.

Yeni bir sağlayıcı eklemek iki adımdan oluşur:

/connect komutuyla sağlayıcının API anahtarlarını ekleyin.
Ardından sağlayıcıyı kodine yapılandırmanızda tanımlayın.

Kimlik Bilgileri

/connect komutuyla eklediğiniz API anahtarları ~/.local/share/kodine/auth.json dosyasında saklanır.

Yapılandırma

Sağlayıcıları, kodine yapılandırmanızdaki provider bölümü üzerinden özelleştirebilirsiniz.

Temel URL

Herhangi bir sağlayıcının temel URL’sini baseURL seçeneğiyle değiştirebilirsiniz. Proxy hizmetleri ya da özel uç noktalar kullanıyorsanız bu seçenek işinize yarar.

{
  "$schema": "https://kodine.net/config.json",
  "provider": {
    "anthropic": {
      "options": {
        "baseURL": "https://api.anthropic.com/v1"
      }
    }
  }
}

Kodine Aura

Kodine Aura, Kodine ekibinin hazırladığı, özenle seçilmiş bir kodlama modeli kadrosudur; modeller yayınlanmadan önce gerçek kodlama görevleriyle sınanır. Daha fazla bilgi.

TUI’de /connect komutunu çalıştırın, Kodine Aura seçeneğini seçin ve kodine.net/auth adresini açın.
```
/connect
```
Oturum açın, fatura bilgilerinizi girin ve API anahtarınızı kopyalayın.
API anahtarınızı yapıştırın.
```
┌ API key
│
│
└ enter
```
Önerilen modellerin listesini görmek için TUI’de /models komutunu çalıştırın.
```
/models
```

Diğer sağlayıcılarla aynı biçimde çalışır ve kullanmak tamamen size bağlıdır.

Dizin

Aşağıda bazı sağlayıcıları ayrıntılı olarak ele alıyoruz. Listeye eklenmesini istediğiniz bir sağlayıcı varsa PR açmaktan çekinmeyin.

302.AI

302.AI konsoluna gidin, hesap açın ve bir API anahtarı oluşturun.
/connect komutunu çalıştırıp 302.AI öğesini bulun.
```
/connect
```
302.AI API anahtarınızı yazın.
```
┌ API key
│
│
└ enter
```
Model seçmek için /models komutunu çalıştırın.
```
/models
```

Amazon Bedrock

Amazon Bedrock’u kodine ile kullanmak için şu adımları izleyin:

Amazon Bedrock konsolunda Model kataloğu bölümünü açın ve kullanmak istediğiniz modeller için erişim isteğinde bulunun.

Kullanacağınız modele Amazon Bedrock üzerinde erişim izniniz olmalı.
Kimlik doğrulamayı ayarlayın: Aşağıdaki yöntemlerden birini seçin:

Ortam Değişkenleri (Hızlı Başlangıç)

kodine’u başlatırken şu ortam değişkenlerinden birini tanımlayın:
Terminal window
```
# Seçenek 1: AWS erişim anahtarlarıyla
AWS_ACCESS_KEY_ID=XXX AWS_SECRET_ACCESS_KEY=YYY kodine

# Seçenek 2: Adlandırılmış AWS profiliyle
AWS_PROFILE=my-profile kodine

# Seçenek 3: Bedrock taşıyıcı belirteciyle
AWS_BEARER_TOKEN_BEDROCK=XXX kodine
```
İsterseniz bunları bash profilinize de ekleyebilirsiniz:
~/.bash_profile
```
export AWS_PROFILE=my-dev-profile
export AWS_REGION=us-east-1
```
Yapılandırma Dosyası (Önerilen)

Kalıcı ya da projeye özel ayarlar için kodine.json kullanın:
kodine.json
```
{
  "$schema": "https://kodine.net/config.json",
  "provider": {
    "amazon-bedrock": {
      "options": {
        "region": "us-east-1",
        "profile": "my-aws-profile"
      }
    }
  }
}
```
Kullanılabilir seçenekler:
- region - AWS bölgesi (ör. us-east-1, eu-west-1)
- profile - ~/.aws/credentials içindeki adlandırılmış AWS profili
- endpoint - VPC uç noktaları için özel uç nokta URL’si (genel baseURL seçeneğinin diğer adı)
Yapılandırma dosyasındaki seçenekler ortam değişkenlerinden önce gelir.

Gelişmiş: VPC Uç Noktaları

Bedrock için VPC uç noktası kullanıyorsanız:

{
  "$schema": "https://kodine.net/config.json",
  "provider": {
    "amazon-bedrock": {
      "options": {
        "region": "us-east-1",
        "profile": "production",
        "endpoint": "https://bedrock-runtime.us-east-1.vpce-xxxxx.amazonaws.com"
      }
    }
  }
}

Kimlik Doğrulama Yöntemleri

AWS_ACCESS_KEY_ID / AWS_SECRET_ACCESS_KEY: Bir IAM kullanıcısı oluşturup AWS konsolundan erişim anahtarları üretin
AWS_PROFILE: ~/.aws/credentials içindeki adlandırılmış profilleri kullanın; öncesinde aws configure --profile my-profile veya aws sso login ile tanımlayın
AWS_BEARER_TOKEN_BEDROCK: Amazon Bedrock konsolundan uzun ömürlü API anahtarları üretin
AWS_WEB_IDENTITY_TOKEN_FILE / AWS_ROLE_ARN: EKS IRSA (Service Account’lar için IAM Rolleri) ya da OIDC federasyonu kullanan diğer Kubernetes ortamları içindir. Hizmet hesabı ek açıklamaları kullanıldığında bu değişkenler Kubernetes tarafından kendiliğinden eklenir.

Kimlik Doğrulama Önceliği

Amazon Bedrock şu öncelik sırasını uygular:

Taşıyıcı belirteç - AWS_BEARER_TOKEN_BEDROCK ortam değişkeni ya da /connect ile girilen belirteç
AWS Credential Chain - Profil, erişim anahtarları, paylaşılan kimlik bilgileri, IAM rolleri, Web Identity Token’lar (EKS IRSA), örnek meta verileri

Kullanmak istediğiniz modeli seçmek için /models komutunu çalıştırın.
```
/models
```

Özel çıkarım profillerinde anahtar olarak model ve sağlayıcı adını kullanıp id özelliğini ARN olarak ayarlayın; böylece önbellekleme doğru çalışır:

{
  "$schema": "https://kodine.net/config.json",
  "provider": {
    "amazon-bedrock": {
      // ...
      "models": {
        "anthropic-claude-sonnet-4.5": {
          "id": "arn:aws:bedrock:us-east-1:xxx:application-inference-profile/yyy"
        }
      }
    }
  }
}

Anthropic

Kaydolduktan sonra /connect komutunu çalıştırın ve Anthropic’i seçin.
```
/connect
```
Açılan ekranda Claude Pro/Max seçeneğini işaretleyebilirsiniz; tarayıcınız açılır ve kimliğinizi doğrulamanız istenir.
```
┌ Select auth method
│
│ Claude Pro/Max
│ Create an API Key
│ Manually enter API Key
└
```
Bundan sonra /models komutunu verdiğinizde tüm Anthropic modelleri listelenir.
```
/models
```

Claude Pro/Max aboneliğinizin kodine ile kullanımı Anthropic tarafından resmi olarak desteklenmez.

Pro/Max aboneliğiniz yoksa API Anahtarı Oluştur seçeneğini de kullanabilirsiniz. Bu seçenek yine tarayıcınızı açar, Anthropic’te oturum açmanızı ister ve terminale yapıştırabileceğiniz bir kod üretir.

Elinizde zaten bir API anahtarı varsa API Anahtarını Manuel Olarak Girin seçeneğini seçip terminale yapıştırabilirsiniz.

Atomic Chat

Yerel LLM’leri OpenAI uyumlu bir API sunucusunun arkasında çalıştıran masaüstü uygulaması Atomic Chat üzerinden kodine’u yerel modellerle kullanabilirsiniz (varsayılan uç nokta http://127.0.0.1:1337/v1).

{
  "$schema": "https://kodine.net/config.json",
  "provider": {
    "atomic-chat": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Atomic Chat (local)",
      "options": {
        "baseURL": "http://127.0.0.1:1337/v1"
      },
      "models": {
        "<your-model-id>": {
          "name": "<your-model-name>"
        }
      }
    }
  }
}

Bu örnekte:

atomic-chat özel sağlayıcı kimliğidir; dilediğiniz herhangi bir metin olabilir.
npm bu sağlayıcı için kullanılacak paketi belirtir. OpenAI uyumlu her API için @ai-sdk/openai-compatible uygundur.
name sağlayıcının arayüzde görünen adıdır.
options.baseURL yerel sunucunun uç noktasıdır. Host ve portu Atomic Chat kurulumunuza göre düzenleyin.
models model kimliklerini görünen adlara eşleyen bir haritadır. Her ID, GET /v1/models yanıtındaki id ile eşleşmelidir; Atomic Chat’te yüklü kimlikleri görmek için curl http://127.0.0.1:1337/v1/models çalıştırın.

Azure OpenAI

Azure portalında bir Azure OpenAI kaynağı oluşturun. Şunlara ihtiyacınız olacak:
- Kaynak adı: API uç noktanızın (https://RESOURCE_NAME.openai.azure.com/) parçasıdır
- API anahtarı: Kaynağınızdaki KEY 1 ya da KEY 2
Azure AI Foundry üzerinden bir model dağıtın.

kodine’un sorunsuz çalışması için dağıtım adı model adıyla aynı olmalıdır.
/connect komutunu çalıştırın ve Azure öğesini bulun.
```
/connect
```
API anahtarınızı girin.
```
┌ API key
│
│
└ enter
```
Kaynak adınızı ortam değişkeni olarak tanımlayın:
Terminal window
```
AZURE_RESOURCE_NAME=XXX kodine
```
Ya da bash profilinize ekleyin:
~/.bash_profile
```
export AZURE_RESOURCE_NAME=XXX
```
Dağıttığınız modeli seçmek için /models komutunu çalıştırın.
```
/models
```

Azure Cognitive Services

Azure portalında bir Azure OpenAI kaynağı oluşturun. Şunlara ihtiyacınız olacak:
- Kaynak adı: API uç noktanızın (https://AZURE_COGNITIVE_SERVICES_RESOURCE_NAME.cognitiveservices.azure.com/) parçasıdır
- API anahtarı: Kaynağınızdaki KEY 1 ya da KEY 2
Azure AI Foundry üzerinden bir model dağıtın.

kodine’un sorunsuz çalışması için dağıtım adı model adıyla aynı olmalıdır.
/connect komutunu çalıştırın ve Azure Cognitive Services öğesini bulun.
```
/connect
```
API anahtarınızı girin.
```
┌ API key
│
│
└ enter
```
Kaynak adınızı ortam değişkeni olarak tanımlayın:
Terminal window
```
AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX kodine
```
Ya da bash profilinize ekleyin:
~/.bash_profile
```
export AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX
```
Dağıttığınız modeli seçmek için /models komutunu çalıştırın.
```
/models
```

Baseten

Baseten adresinde hesap açın ve bir API anahtarı oluşturun.
/connect komutunu çalıştırıp Baseten öğesini bulun.
```
/connect
```
Baseten API anahtarınızı girin.
```
┌ API key
│
│
└ enter
```
Model seçmek için /models komutunu çalıştırın.
```
/models
```

Cerebras

Cerebras konsolunda hesap açın ve bir API anahtarı oluşturun.
/connect komutunu çalıştırıp Cerebras öğesini bulun.
```
/connect
```
Cerebras API anahtarınızı girin.
```
┌ API key
│
│
└ enter
```
Qwen 3 Coder 480B gibi bir model seçmek için /models komutunu çalıştırın.
```
/models
```

Cloudflare AI Gateway

Cloudflare AI Gateway; OpenAI, Anthropic, Workers AI ve daha fazlasındaki modellere tek bir birleşik uç noktadan erişmenizi sağlar. Unified Billing sayesinde her sağlayıcı için ayrı API anahtarına gerek kalmaz.

Cloudflare panosunda AI > AI Gateway bölümüne gidin ve yeni bir ağ geçidi oluşturun.

Hesap Kimliğinizi ve Ağ Geçidi Kimliğinizi ortam değişkeni olarak tanımlayın.

export CLOUDFLARE_ACCOUNT_ID=your-32-character-account-id
export CLOUDFLARE_GATEWAY_ID=your-gateway-id

/connect komutunu çalıştırıp Cloudflare AI Gateway öğesini bulun.
```
/connect
```
Cloudflare API token’ınızı girin.
```
┌ API key
│
│
└ enter
```
Alternatif olarak ortam değişkeni de kullanabilirsiniz.
~/.bash_profile
```
export CLOUDFLARE_API_TOKEN=your-api-token
```

Model seçmek için /models komutunu çalıştırın.

/models

Kodine yapılandırmanız üzerinden de model ekleyebilirsiniz.

{
  "$schema": "https://kodine.net/config.json",
  "provider": {
    "cloudflare-ai-gateway": {
      "models": {
        "openai/gpt-4o": {},
        "anthropic/claude-sonnet-4": {}
      }
    }
  }
}

Cortecs

Cortecs konsolunda hesap açın ve bir API anahtarı oluşturun.
/connect komutunu çalıştırıp Cortecs öğesini bulun.
```
/connect
```
Cortecs API anahtarınızı girin.
```
┌ API key
│
│
└ enter
```
Kimi K2 Instruct gibi bir model seçmek için /models komutunu çalıştırın.
```
/models
```

DeepSeek

DeepSeek konsolunda hesap açın ve Yeni API anahtarı oluştur düğmesine tıklayın.
/connect komutunu çalıştırıp DeepSeek öğesini bulun.
```
/connect
```
DeepSeek API anahtarınızı girin.
```
┌ API key
│
│
└ enter
```
DeepSeek V4 Pro gibi bir DeepSeek modeli seçmek için /models komutunu çalıştırın.
```
/models
```

Deep Infra

Deep Infra panosunda hesap açın ve bir API anahtarı oluşturun.
/connect komutunu çalıştırıp Deep Infra öğesini bulun.
```
/connect
```
Deep Infra API anahtarınızı girin.
```
┌ API key
│
│
└ enter
```
Model seçmek için /models komutunu çalıştırın.
```
/models
```

FrogBot

FrogBot panosunda hesap açın ve bir API anahtarı oluşturun.
/connect komutunu çalıştırıp FrogBot öğesini bulun.
```
/connect
```
FrogBot API anahtarınızı girin.
```
┌ API key
│
│
└ enter
```
Model seçmek için /models komutunu çalıştırın.
```
/models
```

Fireworks AI

Fireworks AI konsolunda hesap açın ve API Anahtarı Oluştur düğmesine tıklayın.
/connect komutunu çalıştırıp Fireworks AI öğesini bulun.
```
/connect
```
Fireworks AI API anahtarınızı girin.
```
┌ API key
│
│
└ enter
```
Kimi K2 Instruct gibi bir model seçmek için /models komutunu çalıştırın.
```
/models
```

GitLab Duo

GitLab Duo, GitLab’ın Anthropic proxy’si aracılığıyla yerleşik araç çağırma yetenekleriyle yapay zeka destekli agent sohbeti sunar.

/connect komutunu çalıştırın ve GitLab’ı seçin.
```
/connect
```
Kimlik doğrulama yönteminizi belirleyin:
```
┌ Select auth method
│
│ OAuth (Recommended)
│ Personal Access Token
└
```
OAuth Kullanımı (Önerilen)

OAuth seçeneğini işaretlediğinizde yetkilendirme için tarayıcınız açılır.

Kişisel Erişim Belirteci Kullanımı
1. GitLab Kullanıcı Ayarları > Access Tokens sayfasını açın
2. Add new token düğmesine tıklayın
3. Ad: Kodine, Kapsamlar: api
4. Oluşan belirteci kopyalayın (glpat- ile başlar)
5. Terminale yapıştırın
Kullanılabilir modelleri görmek için /models komutunu çalıştırın.
```
/models
```
Üç Claude tabanlı model sunulur:
- duo-chat-haiku-4-5 (Varsayılan) - Hızlı işler için çabuk yanıtlar
- duo-chat-sonnet-4-5 - Çoğu iş akışı için dengeli performans
- duo-chat-opus-4-5 - Karmaşık analizler için en yetenekli seçenek

Kendi Kendine Barındırılan GitLab

kodine, oturum başlığı üretmek gibi bazı küçük AI görevleri için küçük bir model kullanır. Varsayılan olarak Kodine Aura üzerinden sunulan kodine-small modeli kullanılacak şekilde ayarlıdır. kodine’u yalnızca kendi barındırdığınız GitLab örneğine bağlamak istiyorsanız kodine.json dosyanıza aşağıdakileri ekleyin. Oturum paylaşımını da kapatmanız önerilir.

{
  "$schema": "https://kodine.net/config.json",
  "small_model": "gitlab/duo-chat-haiku-4-5",
  "share": "disabled"
}

Şirket içinde barındırılan GitLab örnekleri için:

export GITLAB_INSTANCE_URL=https://gitlab.company.com
export GITLAB_TOKEN=glpat-...

Örneğiniz özel bir AI ağ geçidi çalıştırıyorsa:

GITLAB_AI_GATEWAY_URL=https://ai-gateway.company.com

İsterseniz bash profilinize de ekleyebilirsiniz:

export GITLAB_INSTANCE_URL=https://gitlab.company.com
export GITLAB_AI_GATEWAY_URL=https://ai-gateway.company.com
export GITLAB_TOKEN=glpat-...

Kendi Kendine Barındırılan örnekler için OAuth

OAuth’un kendi barındırdığınız örnekte çalışması için yeni bir uygulama oluşturun (Ayarlar → Uygulamalar); geri çağırma URL’si http://127.0.0.1:8080/callback olmalı ve şu kapsamları içermelidir:

api (Adınıza API erişimi)
read_user (Kişisel bilgilerinizi okur)
read_repository (Depoya salt okunur erişim verir)

Ardından uygulama kimliğini ortam değişkeni olarak tanımlayın:

export GITLAB_OAUTH_CLIENT_ID=your_application_id_here

Daha fazla belge için @kodine-ai/gitlab-auth sayfasına bakın.

Yapılandırma

kodine.json üzerinden özelleştirin:

{
  "$schema": "https://kodine.net/config.json",
  "provider": {
    "gitlab": {
      "options": {
        "instanceUrl": "https://gitlab.com"
      }
    }
  }
}

GitLab API Araçları (İsteğe bağlı, ama kesinlikle önerilir)

GitLab araçlarına (birleştirme istekleri, sorunlar, işlem hatları, CI/CD vb.) erişmek için:

{
  "$schema": "https://kodine.net/config.json",
  "plugin": ["kodine-gitlab-plugin"]
}

Bu eklenti; MR incelemeleri, sorun takibi, işlem hattı izleme ve daha fazlasını kapsayan kapsamlı GitLab depo yönetimi yetenekleri sunar.

GitHub Copilot

GitHub Copilot aboneliğinizi kodine ile kullanmak için:

/connect komutunu çalıştırın ve GitHub Copilot’u bulun.
```
/connect
```

github.com/login/device adresini açıp kodu girin.

┌ Login with GitHub Copilot
│
│ https://github.com/login/device
│
│ Enter code: 8F43-6FCF
│
└ Waiting for authorization...

Artık istediğiniz modeli seçmek için /models komutunu çalıştırabilirsiniz.
```
/models
```

Google Vertex AI

Google Vertex AI’yi kodine ile kullanmak için:

Google Cloud Console’daki Model Garden bölümünü açın ve bölgenizde kullanılabilir modelleri kontrol edin.

Vertex AI API’sinin etkinleştirildiği bir Google Cloud projeniz olmalı.
Gerekli ortam değişkenlerini tanımlayın:
- GOOGLE_CLOUD_PROJECT: Google Cloud proje kimliğiniz
- VERTEX_LOCATION (isteğe bağlı): Vertex AI bölgesi (varsayılanı global)
- Kimlik doğrulama (birini seçin):
  - GOOGLE_APPLICATION_CREDENTIALS: Servis hesabı JSON anahtar dosyanızın yolu
  - gcloud CLI ile kimlik doğrulama: gcloud auth application-default login
Bunları kodine’u başlatırken ayarlayın.
Terminal window
```
GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json GOOGLE_CLOUD_PROJECT=your-project-id kodine
```
İsterseniz bash profilinize de ekleyebilirsiniz.
~/.bash_profile
```
export GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json
export GOOGLE_CLOUD_PROJECT=your-project-id
export VERTEX_LOCATION=global
```

Kullanmak istediğiniz modeli seçmek için /models komutunu çalıştırın.
```
/models
```

Groq

Groq konsolunda API Anahtarı Oluştur düğmesine tıklayıp anahtarı kopyalayın.
/connect komutunu çalıştırıp Groq’u bulun.
```
/connect
```
Sağlayıcının API anahtarını girin.
```
┌ API key
│
│
└ enter
```
İstediğinizi seçmek için /models komutunu çalıştırın.
```
/models
```

Hugging Face

Hugging Face Inference Providers, 17’den fazla sağlayıcının desteklediği açık modellere erişim sunar.

Inference Providers’a istek atma iznine sahip bir belirteç üretmek için Hugging Face ayarlarını açın.
/connect komutunu çalıştırıp Hugging Face öğesini bulun.
```
/connect
```
Hugging Face token’ınızı girin.
```
┌ API key
│
│
└ enter
```
Kimi-K2-Instruct veya GLM-4.6 gibi bir model seçmek için /models komutunu çalıştırın.
```
/models
```

Helicone

Helicone, AI uygulamalarınıza günlükleme, izleme ve analiz sağlayan bir LLM gözlemlenebilirlik platformudur. Helicone AI Gateway, isteklerinizi modele göre otomatik olarak uygun sağlayıcıya yönlendirir.

Helicone adresinde hesap açın ve panonuzdan bir API anahtarı üretin.
/connect komutunu çalıştırıp Helicone öğesini bulun.
```
/connect
```
Helicone API anahtarınızı girin.
```
┌ API key
│
│
└ enter
```
Model seçmek için /models komutunu çalıştırın.
```
/models
```

Daha fazla sağlayıcı ile önbellekleme ve hız sınırlama gibi gelişmiş özellikler için Helicone belgelerine bakın.

İsteğe Bağlı Yapılandırmalar

Helicone’un kodine tarafından otomatik yapılandırılmayan bir özelliğini ya da modelini görmek isterseniz kendiniz tanımlayabilirsiniz.

Eklemek istediğiniz modellerin kimlikleri için Helicone Model Dizini sayfasına ihtiyacınız olacak.

{
  "$schema": "https://kodine.net/config.json",
  "provider": {
    "helicone": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Helicone",
      "options": {
        "baseURL": "https://ai-gateway.helicone.ai",
      },
      "models": {
        "gpt-4o": {
          // Model ID (from Helicone's model directory page)
          "name": "GPT-4o", // Your own custom name for the model
        },
        "claude-sonnet-4-20250514": {
          "name": "Claude Sonnet 4",
        },
      },
    },
  },
}

Özel Başlıklar

Helicone; önbellekleme, kullanıcı takibi ve oturum yönetimi gibi özellikler için özel başlıkları destekler. options.headers ile bunları sağlayıcı yapılandırmanıza ekleyin:

{
  "$schema": "https://kodine.net/config.json",
  "provider": {
    "helicone": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Helicone",
      "options": {
        "baseURL": "https://ai-gateway.helicone.ai",
        "headers": {
          "Helicone-Cache-Enabled": "true",
          "Helicone-User-Id": "kodine",
        },
      },
    },
  },
}

Oturum izleme

Helicone’un Sessions özelliği, ilişkili LLM isteklerini birlikte gruplandırmanızı sağlar. Her kodine görüşmesini Helicone’da otomatik olarak bir oturum olarak kaydetmek için kodine-helicone-session eklentisini kullanın.

npm install -g kodine-helicone-session

Yapılandırmanıza ekleyin.

{
  "plugin": ["kodine-helicone-session"]
}

Eklenti, isteklerinize Helicone-Session-Id ve Helicone-Session-Name başlıklarını ekler. Helicone’un Sessions sayfasında her kodine görüşmesinin ayrı bir oturum olarak listelendiğini görürsünüz.

Yaygın Helicone başlıkları

Başlık	Açıklama
`Helicone-Cache-Enabled`	Yanıt önbelleğini açar (`true`/`false`)
`Helicone-User-Id`	Metrikleri kullanıcı bazında izler
`Helicone-Property-[Name]`	Özel özellikler ekler (örn. `Helicone-Property-Environment`)
`Helicone-Prompt-Id`	İstekleri prompt sürümleriyle ilişkilendirir

Mevcut tüm başlıklar için Helicone Header Directory sayfasına bakın.

llama.cpp

kodine’u, llama.cpp’nin llama-server aracı üzerinden yerel modellerle kullanacak şekilde yapılandırabilirsiniz.

{
  "$schema": "https://kodine.net/config.json",
  "provider": {
    "llama.cpp": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "llama-server (local)",
      "options": {
        "baseURL": "http://127.0.0.1:8080/v1"
      },
      "models": {
        "qwen3-coder:a3b": {
          "name": "Qwen3-Coder: a3b-30b (local)",
          "limit": {
            "context": 128000,
            "output": 65536
          }
        }
      }
    }
  }
}

Bu örnekte:

llama.cpp özel sağlayıcı kimliğidir; dilediğiniz herhangi bir metin olabilir.
npm bu sağlayıcı için kullanılacak paketi belirtir. OpenAI uyumlu her API için @ai-sdk/openai-compatible uygundur.
name sağlayıcının arayüzde görünen adıdır.
options.baseURL yerel sunucunun uç noktasıdır.
models model kimliklerini yapılandırmalarına eşleyen bir haritadır. Model adı, model seçim listesinde görünür.

IO.NET

IO.NET, farklı kullanım senaryoları için optimize edilmiş 17 model sunar:

IO.NET konsolunda hesap açın ve bir API anahtarı oluşturun.
/connect komutunu çalıştırıp IO.NET öğesini bulun.
```
/connect
```
IO.NET API anahtarınızı girin.
```
┌ API key
│
│
└ enter
```
Model seçmek için /models komutunu çalıştırın.
```
/models
```

LM Studio

kodine’u LM Studio üzerinden yerel modellerle kullanacak şekilde yapılandırabilirsiniz.

{
  "$schema": "https://kodine.net/config.json",
  "provider": {
    "lmstudio": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "LM Studio (local)",
      "options": {
        "baseURL": "http://127.0.0.1:1234/v1"
      },
      "models": {
        "google/gemma-3n-e4b": {
          "name": "Gemma 3n-e4b (local)"
        }
      }
    }
  }
}

Bu örnekte:

lmstudio özel sağlayıcı kimliğidir; dilediğiniz herhangi bir metin olabilir.
npm bu sağlayıcı için kullanılacak paketi belirtir. OpenAI uyumlu her API için @ai-sdk/openai-compatible uygundur.
name sağlayıcının arayüzde görünen adıdır.
options.baseURL yerel sunucunun uç noktasıdır.
models model kimliklerini yapılandırmalarına eşleyen bir haritadır. Model adı, model seçim listesinde görünür.

Moonshot AI

Moonshot AI’dan Kimi K2’yi kullanmak için:

Moonshot AI konsolunda hesap açın ve API anahtarı oluştur düğmesine tıklayın.
/connect komutunu çalıştırıp Moonshot AI öğesini bulun.
```
/connect
```
Moonshot API anahtarınızı girin.
```
┌ API key
│
│
└ enter
```
Kimi K2 modelini seçmek için /models komutunu çalıştırın.
```
/models
```

MiniMax

MiniMax API konsolunda hesap açın ve bir API anahtarı oluşturun.
/connect komutunu çalıştırıp MiniMax öğesini bulun.
```
/connect
```
MiniMax API anahtarınızı girin.
```
┌ API key
│
│
└ enter
```
M2.1 gibi bir model seçmek için /models komutunu çalıştırın.
```
/models
```

Nebius Token Factory

Nebius Token Factory konsolunda hesap açın ve Anahtar Ekle düğmesine tıklayın.
/connect komutunu çalıştırıp Nebius Token Factory öğesini bulun.
```
/connect
```
Nebius Token Factory API anahtarınızı girin.
```
┌ API key
│
│
└ enter
```
Kimi K2 Instruct gibi bir model seçmek için /models komutunu çalıştırın.
```
/models
```

Ollama

kodine’u Ollama üzerinden yerel modellerle kullanacak şekilde yapılandırabilirsiniz.

{
  "$schema": "https://kodine.net/config.json",
  "provider": {
    "ollama": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Ollama (local)",
      "options": {
        "baseURL": "http://localhost:11434/v1"
      },
      "models": {
        "llama2": {
          "name": "Llama 2"
        }
      }
    }
  }
}

Bu örnekte:

ollama özel sağlayıcı kimliğidir; dilediğiniz herhangi bir metin olabilir.
npm bu sağlayıcı için kullanılacak paketi belirtir. OpenAI uyumlu her API için @ai-sdk/openai-compatible uygundur.
name sağlayıcının arayüzde görünen adıdır.
options.baseURL yerel sunucunun uç noktasıdır.
models model kimliklerini yapılandırmalarına eşleyen bir haritadır. Model adı, model seçim listesinde görünür.

Ollama Cloud

Ollama Cloud’u kodine ile kullanmak için:

https://ollama.com/ adresini açıp oturum açın veya hesap oluşturun.
Ayarlar > Anahtarlar bölümüne gidin ve API Anahtarı Ekle düğmesiyle yeni bir API anahtarı üretin.
API anahtarını kodine’da kullanmak üzere kopyalayın.
/connect komutunu çalıştırıp Ollama Cloud öğesini bulun.
```
/connect
```
Ollama Cloud API anahtarınızı girin.
```
┌ API key
│
│
└ enter
```
Önemli: kodine’da bulut modellerini kullanmadan önce model bilgilerini yerel olarak indirmeniz gerekir:
Terminal window
```
ollama pull gpt-oss:20b-cloud
```
Ollama Cloud modelinizi seçmek için /models komutunu çalıştırın.
```
/models
```

OpenAI

ChatGPT Plus veya Pro aboneliği almanızı öneririz.

Kaydolduktan sonra /connect komutunu çalıştırın ve OpenAI’yi seçin.
```
/connect
```
Açılan ekranda ChatGPT Plus/Pro seçeneğini işaretleyebilirsiniz; tarayıcınız açılır ve kimliğinizi doğrulamanız istenir.
```
┌ Select auth method
│
│ ChatGPT Plus/Pro
│ Manually enter API Key
└
```
Bundan sonra /models komutunu verdiğinizde tüm OpenAI modelleri listelenir.
```
/models
```

API anahtarlarını kullanma

Elinizde zaten bir API anahtarı varsa API Anahtarını Manuel Olarak Girin seçeneğini seçip terminale yapıştırabilirsiniz.

Kodine Aura

Kodine Aura, Kodine ekibinin özenle seçtiği kodlama modellerinden oluşan bir listedir. Daha fazla bilgi.

Kodine Aura üzerinde oturum açın ve API Anahtarı Oluştur düğmesine tıklayın.
/connect komutunu çalıştırıp Kodine Aura öğesini bulun.
```
/connect
```
Kodine API anahtarınızı girin.
```
┌ API key
│
│
└ enter
```
Kodine Large gibi bir model seçmek için /models komutunu çalıştırın.
```
/models
```

OpenRouter

OpenRouter panosunda API Anahtarı Oluştur düğmesine tıklayıp anahtarı kopyalayın.
/connect komutunu çalıştırıp OpenRouter’ı bulun.
```
/connect
```
Sağlayıcının API anahtarını girin.
```
┌ API key
│
│
└ enter
```
Pek çok OpenRouter modeli hazır olarak yüklü gelir; istediğinizi seçmek için /models komutunu çalıştırın.
```
/models
```
kodine yapılandırmanız üzerinden ek model de tanımlayabilirsiniz.
kodine.json
```
{
  "$schema": "https://kodine.net/config.json",
  "provider": {
    "openrouter": {
      "models": {
        "somecoolnewmodel": {}
      }
    }
  }
}
```

Bunları kodine yapılandırmanızla özelleştirmeniz de mümkün. Aşağıda bir sağlayıcı belirtme örneği var:

{
  "$schema": "https://kodine.net/config.json",
  "provider": {
    "openrouter": {
      "models": {
        "moonshotai/kimi-k2": {
          "options": {
            "provider": {
              "order": ["baseten"],
              "allow_fallbacks": false
            }
          }
        }
      }
    }
  }
}

SAP AI Core

SAP AI Core; OpenAI, Anthropic, Google, Amazon, Meta, Mistral ve AI21’in 40’tan fazla modeline tek bir birleşik platform üzerinden erişim sunar.

SAP BTP Cockpit sunucunuzu açın, SAP AI Core servis örneğinize gidin ve bir servis anahtarı oluşturun.

Servis anahtarı; clientid, clientsecret, url ve serviceurls.AI_API_URL alanlarını içeren bir JSON nesnesidir. AI Core örneğinizi BTP Cockpit’te Hizmetler > Örnekler ve Abonelikler altında bulabilirsiniz.
/connect komutunu çalıştırıp SAP AI Core öğesini bulun.
```
/connect
```

Servis anahtarınızı JSON olarak girin.

┌ Service key
│
│
└ enter

Alternatif olarak AICORE_SERVICE_KEY ortam değişkenini tanımlayın:

AICORE_SERVICE_KEY='{"clientid":"...","clientsecret":"...","url":"...","serviceurls":{"AI_API_URL":"..."}}' kodine

Ya da bash profilinize ekleyin:

export AICORE_SERVICE_KEY='{"clientid":"...","clientsecret":"...","url":"...","serviceurls":{"AI_API_URL":"..."}}'

İsteğe bağlı olarak dağıtım kimliğini ve kaynak grubunu da ayarlayın:
Terminal window
```
AICORE_DEPLOYMENT_ID=your-deployment-id AICORE_RESOURCE_GROUP=your-resource-group kodine
```
Bu ayarlar isteğe bağlıdır ve SAP AI Core kurulumunuza göre belirlenmelidir.
40’tan fazla model arasından seçim yapmak için /models komutunu çalıştırın.
```
/models
```

STACKIT

STACKIT AI Model Serving; Llama, Mistral ve Qwen gibi LLM’lere odaklanan, Avrupa altyapısında maksimum veri egemenliği sağlayan, tamamen yönetilen bağımsız bir barındırma ortamıdır.

STACKIT Portalında AI Model Serving bölümüne gidin ve projeniz için bir yetkilendirme belirteci oluşturun.

Yetkilendirme belirteci üretmeden önce bir STACKIT müşteri hesabına, kullanıcı hesabına ve projesine ihtiyacınız var.
/connect komutunu çalıştırıp STACKIT öğesini bulun.
```
/connect
```
STACKIT AI Model Serving yetkilendirme belirtecinizi girin.
```
┌ API key
│
│
└ enter
```
Qwen3-VL 235B veya Llama 3.3 70B gibi mevcut modeller arasından seçim yapmak için /models komutunu çalıştırın.
```
/models
```

OVHcloud AI Endpoints

OVHcloud panelini açın. Public Cloud bölümüne gidin, AI & Machine Learning > AI Endpoints yolunu izleyin ve API Keys sekmesinde Yeni bir API anahtarı oluştur düğmesine tıklayın.
/connect komutunu çalıştırıp OVHcloud AI Endpoints öğesini bulun.
```
/connect
```
OVHcloud AI Endpoints API anahtarınızı girin.
```
┌ API key
│
│
└ enter
```
gpt-oss-120b gibi bir model seçmek için /models komutunu çalıştırın.
```
/models
```

Scaleway

Scaleway Generative APIs’ı Kodine ile kullanmak için:

Yeni bir API anahtarı üretmek için Scaleway Console IAM ayarlarını açın.
/connect komutunu çalıştırıp Scaleway öğesini bulun.
```
/connect
```
Scaleway API anahtarınızı girin.
```
┌ API key
│
│
└ enter
```
devstral-2-123b-instruct-2512 veya gpt-oss-120b gibi bir model seçmek için /models komutunu çalıştırın.
```
/models
```

Together AI

Together AI konsolunda hesap açın ve Anahtar Ekle düğmesine tıklayın.
/connect komutunu çalıştırıp Together AI öğesini bulun.
```
/connect
```
Together AI API anahtarınızı girin.
```
┌ API key
│
│
└ enter
```
Kimi K2 Instruct gibi bir model seçmek için /models komutunu çalıştırın.
```
/models
```

Venice AI

Venice AI konsolunda hesap açın ve bir API anahtarı oluşturun.
/connect komutunu çalıştırıp Venice AI öğesini bulun.
```
/connect
```
Venice AI API anahtarınızı girin.
```
┌ API key
│
│
└ enter
```
Llama 3.3 70B gibi bir model seçmek için /models komutunu çalıştırın.
```
/models
```

Vercel AI Gateway

Vercel AI Gateway; OpenAI, Anthropic, Google, xAI ve daha fazlasındaki modellere tek bir birleşik uç noktadan erişmenizi sağlar. Modeller herhangi bir fark eklenmeden liste fiyatıyla sunulur.

Vercel panosunda AI Gateway sekmesine gidin ve API anahtarları üzerinden yeni bir API anahtarı oluşturun.
/connect komutunu çalıştırıp Vercel AI Gateway öğesini bulun.
```
/connect
```
Vercel AI Gateway API anahtarınızı girin.
```
┌ API key
│
│
└ enter
```
Model seçmek için /models komutunu çalıştırın.
```
/models
```

Modelleri kodine yapılandırmanızla da özelleştirebilirsiniz. Aşağıda sağlayıcı yönlendirme sırasını belirten bir örnek var:

{
  "$schema": "https://kodine.net/config.json",
  "provider": {
    "vercel": {
      "models": {
        "anthropic/claude-sonnet-4": {
          "options": {
            "order": ["anthropic", "vertex"]
          }
        }
      }
    }
  }
}

Bazı faydalı yönlendirme seçenekleri:

Seçenek	Açıklama
`order`	Denenecek sağlayıcı sırası
`only`	Belirli sağlayıcılarla sınırlar
`zeroDataRetention`	Yalnızca sıfır veri saklama politikası uygulayan sağlayıcıları kullanır

xAI

xAI konsolunda hesap açın ve bir API anahtarı oluşturun.
/connect komutunu çalıştırıp xAI öğesini bulun.
```
/connect
```
xAI API anahtarınızı girin.
```
┌ API key
│
│
└ enter
```
Grok Beta gibi bir model seçmek için /models komutunu çalıştırın.
```
/models
```

Z.AI

Z.AI API konsolunda hesap açın ve Yeni bir API anahtarı oluştur düğmesine tıklayın.
/connect komutunu çalıştırıp Z.AI öğesini bulun.
```
/connect
```
GLM Kodlama Planı abonesiyseniz Z.AI Kodlama Planı seçeneğini işaretleyin.
Z.AI API anahtarınızı girin.
```
┌ API key
│
│
└ enter
```
GLM-4.7 gibi bir model seçmek için /models komutunu çalıştırın.
```
/models
```

ZenMux

ZenMux panosunda API Anahtarı Oluştur düğmesine tıklayıp anahtarı kopyalayın.
/connect komutunu çalıştırıp ZenMux’u bulun.
```
/connect
```
Sağlayıcının API anahtarını girin.
```
┌ API key
│
│
└ enter
```
ZenMux modellerinin çoğu hazır olarak yüklü gelir; istediğinizi seçmek için /models komutunu çalıştırın.
```
/models
```
kodine yapılandırmanız üzerinden ek model de tanımlayabilirsiniz.
kodine.json
```
{
  "$schema": "https://kodine.net/config.json",
  "provider": {
    "zenmux": {
      "models": {
        "somecoolnewmodel": {}
      }
    }
  }
}
```

Özel sağlayıcı

/connect listesinde yer almayan herhangi bir OpenAI uyumlu sağlayıcıyı eklemek için:

/connect komutunu çalıştırın ve Diğer seçeneğine gidin.

$ /connect

┌  Add credential
│
◆  Select provider
│  ...
│  ● Other
└

Sağlayıcı için benzersiz bir kimlik girin.
Terminal window
```
$ /connect

┌  Add credential
│
◇  Enter provider id
│  myprovider
└
```
Akılda kalıcı bir kimlik seçin; yapılandırma dosyanızda bu kimliği kullanacaksınız.

Sağlayıcınızın API anahtarını girin.

$ /connect

┌  Add credential
│
▲  This only stores a credential for myprovider - you will need to configure it in kodine.json, check the docs for examples.
│
◇  Enter your API key
│  sk-...
└

Proje dizininizdeki kodine.json dosyanızı oluşturun veya güncelleyin:
kodine.json
```
{
  "$schema": "https://kodine.net/config.json",
  "provider": {
    "myprovider": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "My AI ProviderDisplay Name",
      "options": {
        "baseURL": "https://api.myprovider.com/v1"
      },
      "models": {
        "my-model-name": {
          "name": "My Model Display Name"
        }
      }
    }
  }
}
```
Yapılandırma seçenekleri şunlardır:
- npm: Kullanılacak AI SDK paketi; OpenAI uyumlu sağlayıcılar için @ai-sdk/openai-compatible
- name: Arayüzde görünen ad
- models: Kullanılabilir modeller
- options.baseURL: API uç nokta URL’si
- options.apiKey: Kimlik doğrulama kullanılmıyorsa API anahtarını isteğe bağlı olarak burada ayarlayın
- options.headers: İsteğe bağlı özel başlıklar
Gelişmiş seçenekler hakkında daha fazlasını aşağıdaki örnekte bulabilirsiniz.
/models komutunu çalıştırın; özel sağlayıcınız ve modelleri seçim listesinde görünür.

Örnek

Aşağıda apiKey, headers ve model limit seçeneklerinin ayarlandığı bir örnek var:

{
  "$schema": "https://kodine.net/config.json",
  "provider": {
    "myprovider": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "My AI ProviderDisplay Name",
      "options": {
        "baseURL": "https://api.myprovider.com/v1",
        "apiKey": "{env:ANTHROPIC_API_KEY}",
        "headers": {
          "Authorization": "Bearer custom-token"
        }
      },
      "models": {
        "my-model-name": {
          "name": "My Model Display Name",
          "limit": {
            "context": 200000,
            "output": 65536
          }
        }
      }
    }
  }
}

Yapılandırma ayrıntıları:

apiKey: env değişken sözdizimiyle ayarlanır; daha fazla bilgi.
headers: Her istekle birlikte gönderilen özel başlıklar.
limit.context: Modelin kabul ettiği maksimum girdi token sayısı.
limit.output: Modelin üretebileceği maksimum token sayısı.

limit alanları, kodine’un kalan bağlam miktarınızı hesaplayabilmesini sağlar. Standart sağlayıcılar bu değerleri models.dev üzerinden otomatik alır.

Sorun Giderme

Sağlayıcı kurulumunda sorun yaşıyorsanız şunları kontrol edin:

Kimlik doğrulama kurulumunu doğrulayın: kodine auth list komutunu çalıştırarak kimlik bilgilerinin geçerli olup olmadığını ve sağlayıcı yapılandırmanıza eklenip eklenmediğini görün.

Bu, kimlik doğrulamada ortam değişkenlerine dayanan Amazon Bedrock gibi sağlayıcılar için geçerli değildir.
Özel sağlayıcılarda kodine yapılandırmasını gözden geçirin ve şunlardan emin olun:
- /connect sırasında kullandığınız sağlayıcı kimliği, kodine yapılandırmanızdaki kimlikle birebir aynı.
- Sağlayıcı için doğru npm paketi seçili. Örneğin Cerebras için @ai-sdk/cerebras kullanın; diğer tüm OpenAI uyumlu sağlayıcılar için @ai-sdk/openai-compatible yeterlidir.
- options.baseURL alanında doğru API uç noktası tanımlı.