YandexGPT Mobile App Integration: Secure & Streamlined
This YandexGPT mobile app integration guide covers everything from architecture to implementation. When trying to directly use an IAM token in a mobile app, users hit a 401 Unauthorized error after 12 hours—the token expires. An API key, if embedded in the APK, can be extracted via reverse engineering in minutes. The solution is a proxy service on your own backend. This article covers the architecture and key YandexGPT integration points for iOS and Android, with specific focus on mobile chatbot scenarios.
YandexGPT gives an edge where Russian language semantics matter: user support, form autofill, content generation with local vocabulary. OpenAI models excel at English, but YandexGPT handles regional queries and specific terms more accurately—it performs 30% better than generic models in Russian semantic tasks. The integration task seems simple—POST to https://llm.api.cloud.yandex.net/foundationModels/v1/completion, pass IAM token and text. In practice, it's a chain of non-trivial decisions we've refined across dozens of projects.
How to Set Up IAM Token for Mobile App?
The first choke point is authorization. An IAM token lives 12 hours; an API key is permanent but less secure. Storing a service key directly in a mobile app is not safe—it can be extracted from the APK in minutes using apktool. The correct architecture: the mobile client authenticates with your backend, which holds the IAM token and proxies requests to Yandex Cloud.
// iOS YandexGPT integration: request via custom proxy
struct YGPTRequest: Encodable {
let prompt: String
let maxTokens: Int
let temperature: Double
}
func sendToYandexGPT(prompt: String) async throws -> String {
let url = URL(string: "https://api.yourapp.com/ai/complete")!
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer \(authToken)", forHTTPHeaderField: "Authorization")
request.httpBody = try JSONEncoder().encode(YGPTRequest(
prompt: prompt,
maxTokens: 500,
temperature: 0.7
))
let (data, _) = try await URLSession.shared.data(for: request)
return try JSONDecoder().decode(CompletionResponse.self, from: data).text
}
This demonstrates iOS YandexGPT integration. On Android—similarly with Retrofit and an OkHttp interceptor for token injection in Android YandexGPT integration.
What Are the Benefits of Streaming Generation?
Enabling stream: true in the Yandex Foundation Models API returns response chunks—like in ChatGPT. For mobile UX, this matters: users see text as it's generated, without waiting 3–5 seconds. We ensure streaming doesn't increase device load when implemented correctly.
On iOS, handle Server-Sent Events via URLSessionDataDelegate:
class StreamingDelegate: NSObject, URLSessionDataDelegate {
var onChunk: (String) -> Void
var buffer = Data()
func urlSession(_ session: URLSession,
dataTask: URLSessionDataTask,
didReceive data: Data) {
buffer.append(data)
guard let text = String(data: buffer, encoding: .utf8) else { return }
let lines = text.components(separatedBy: "\n")
for line in lines where line.hasPrefix("data: ") {
let json = String(line.dropFirst(6))
if let chunk = parseYGPTChunk(json) {
DispatchQueue.main.async { self.onChunk(chunk) }
}
}
}
}
On Android—use OkHttp with EventSource (library okhttp-sse) or manual parsing with BufferedReader line by line.
Choosing the Right YandexGPT Model
Yandex offers several variants: yandexgpt-lite—fast and cheap, yandexgpt—full version, yandexgpt-32k—for long contexts. For most mobile scenarios (chat suggestions, autofill), yandexgpt-lite is sufficient and noticeably faster.
| Model | Context | Response Speed | Use Case |
|---|---|---|---|
| yandexgpt-lite | 8k tokens | ~1–2 sec | Prompts, summaries |
| yandexgpt | 8k tokens | ~3–5 sec | Complex tasks |
| yandexgpt-32k | 32k tokens | ~8–15 sec | Long documents |
The temperature parameter ranges from 0 to 1: 0.2–0.4 for deterministic responses (FAQ bot), 0.7–0.9 for creative text. We recommend a system prompt in Russian—it improves response relevance.
For more on models, see Yandex Cloud API documentation.
Caching and Limits
Yandex Cloud charges per token. On a mobile client, you must cache repeated requests—a typical pattern for FAQ or onboarding. A simple LRU cache with 100 entries in memory reduces costs during repeated sessions. We use request caching in all our projects—savings up to 40% on API calls. For a typical project, this reduces monthly API costs from $500 to $300, saving $200 per month. Typical project costs for our YandexGPT integration service range from $2,000 to $5,000 depending on complexity.
The default rate limit for Yandex Foundation Models is 10 RPS per folder. During peak loads, a backend queue is needed instead of direct calls from each device. We'll evaluate your project and help choose the architecture. For detailed YandexGPT pricing, see the official documentation.
What's Included
- Scenario audit: profiling user requests, assessing required context depth.
- Architecture design: YandexGPT proxy service, IAM token management, caching.
- Mobile integration (iOS/Android) with streaming support.
- Response quality testing on real data, system prompt tuning.
- API documentation and code examples.
- Training your team on Yandex Cloud operations.
Process
- Scenario audit: identify where LLM is needed—support, text generation, classification.
- Model and mode selection (synchronous / stream).
- Backend proxy service development with IAM token management.
- Mobile integration with UI for streaming generation.
- Response quality testing on real user queries, system prompt tuning.
- Handover of documentation and final demo.
Example Android Architecture
// Retrofit interface
interface YandexGPTProxy {
@POST("ai/complete")
suspend fun complete(@Body request: CompletionRequest): CompletionResponse
}
// ViewModel with caching
class ChatViewModel(private val api: YandexGPTProxy) : ViewModel() {
private val cache = LruCache<String, String>(100)
fun sendPrompt(prompt: String) = viewModelScope.launch {
cache.get(prompt)?.let { /* use cached */ }
val result = api.complete(CompletionRequest(prompt))
cache.put(prompt, result.text)
}
}
This pattern is common in Android YandexGPT integration.
Estimated Timelines
| Stage | Duration (days) |
|---|---|
| Basic proxy integration (no streaming) | 2–3 days |
| Full chat interface with streaming | 5–8 days |
| Caching optimization and error handling | +1–2 days |
With over 5 years of experience in AI integration and 50+ successful projects, our team ensures reliable and optimized YandexGPT mobile solutions. Cost is calculated individually based on complexity and scope. Get a consultation: we'll estimate your project within one business day. Contact us to discuss details.