जब भी Octocode एक सेमांटिक खोज चलाता है, जब भी Octomind किसी प्रॉम्प्ट को सही मॉडल तक रूट करता है, जब भी हमारे किसी उत्पाद का LLM से संवाद होता है — सब कुछ एक ही कोड के टुकड़े से होकर गुज़रता है। हमने पिछले साल इसे Octocode से निकाला था। अब यह सब कुछ चलाता है।

इसे Octolib कहते हैं। और हमने अभी इसे ओपन-सोर्स कर दिया।

आंतरिक गोंद से साझा बुनियादी ढाँचे तक

Octolib Octocode के उस गंदे हिस्से के रूप में शुरू हुआ जिसके बारे में कोई सोचना नहीं चाहता था।

Octocode को कोड को सेमांटिक रूप से समझने के लिए embeddings चाहिए। आपके कोडबेस के बारे में सवालों के जवाब देने के लिए LLMs। उन परिणामों को सामने लाने के लिए reranking जो वास्तव में मायने रखते हैं। शुरुआत में, इसका मतलब था तीन अलग-अलग क्लाइंट लाइब्रेरियाँ, तीन अलग-अलग error handling पैटर्न और टोकन उपयोग को parse करने के तीन अलग-अलग तरीके। (मुझे अब भी याद है कि Cohere embeddings जोड़ते समय एक vector पाने के लिए ही उनका पूरा SDK सीखना पड़ा था।)

एक नया provider जोड़ने का मतलब था छह जगहों पर कोड को छूना। हमने वही किया जो ज़्यादातर टीमें करती हैं: एक पतला wrapper लिख दिया।

फिर wrapper में फीचर्स जुड़ने लगे। फिर providers। फिर हमें एहसास हुआ कि Octomind — हमारा AI agent प्लेटफ़ॉर्म — को ठीक यही चीज़ चाहिए। Octobrain को भी।

wrapper को तीन बार कॉपी-पेस्ट करना मूर्खतापूर्ण लगा। उसे निकाल लेना स्पष्ट लगा।

Octolib वही निकालना है। LLM इन्फरेंस, embeddings और reranking के लिए हर प्रमुख provider के साथ काम करने वाली एक आत्मनिर्भर Rust लाइब्रेरी।

एक स्ट्रिंग, कोई भी backend

विचार सरल है। एक provider:model स्ट्रिंग। एक API। कोई भी backend।

let provider = ProviderFactory::get_provider_for_model("openai:gpt-5.5")?;
let response = provider.chat_completion(params).await?;

openai:gpt-5.5 को anthropic:claude-opus-4-5-20251101, deepseek:deepseek-chat, nvidia:meta/llama-3.3-70b-instruct, या openrouter:anthropic/claude-opus-4.5 से बदल दीजिए। कोड नहीं बदलता। response का प्रकार नहीं बदलता। टोकन उपयोग और लागत ट्रैकिंग अब भी काम करती है।

यहाँ वह trait है जो इसे संभव बनाता है:

#[async_trait]
pub trait AiProvider {
    fn name(&self) -> &str;
    fn supports_model(&self, model: &str) -> bool;
    async fn chat_completion(&self, params: ChatCompletionParams) -> Result<ProviderResponse>;
    fn get_model_pricing(&self, model: &str) -> Option<Pricing>;
}

हर provider एक ही interface लागू करता है। OpenAI का अपना native कार्यान्वयन है। NVIDIA NIM, Cerebras, Together, Ollama और local endpoints सभी एक साझा OpenAI-compatible परत से होकर गुज़रते हैं। factory model स्ट्रिंग parsing संभालती है और सही backend तक रूट करती है।

जानबूझकर उबाऊ। यही पूरा बिंदु है।

LLM providers

Provider प्रकार चैट Structured output Caching
OpenAI Native ✅ ✅ —
Anthropic Native ✅ ✅ ✅
Google (Gemini) Native ✅ ✅ —
DeepSeek Native ✅ ✅ —
Moonshot Native ✅ ✅ —
MiniMax Native ✅ ✅ —
Z.ai Native ✅ — —
OpenRouter OpenAI-compatible ✅ ✅ —
NVIDIA NIM OpenAI-compatible ✅ — —
Cerebras OpenAI-compatible ✅ — —
Together OpenAI-compatible ✅ — —
Cloudflare Workers AI OpenAI-compatible ✅ — —
OctoHub OpenAI-compatible ✅ — —
Ollama OpenAI-compatible ✅ — —
Local endpoints OpenAI-compatible ✅ — —

Embeddings और reranking

Provider Embeddings Reranking Local
Jina ✅ ✅ —
Voyage ✅ ✅ —
Cohere — ✅ —
OpenAI ✅ — —
Google ✅ — —
FastEmbed ✅ ✅ ✅

नए providers pull request के रूप में आते हैं। यदि आपको कोई ऐसा चाहिए जो गायब है, तो template src/llm/providers/openai.rs में है।

वे हिस्से जिनके बारे में तब तक कोई बात नहीं करता जब तक वे टूट न जाएँ

मल्टी-provider लाइब्रेरियाँ अब दुर्लभ नहीं हैं। फ़र्क उन बारीकियों में है जो तभी मायने रखती हैं जब आप उन्हें कड़ी मेहनत से चला रहे हों।

लागत ट्रैकिंग। हर response में टोकन उपयोग और गणना की गई लागत शामिल होती है। Native API providers के लिए, हम प्रति-मॉडल pricing tables रखते हैं। open-weight मॉडल होस्ट करने वाले proxies और aggregators के लिए, हम मॉडल नाम से मिलाई गई reference pricing पर fallback करते हैं। यदि upstream API एक cost field वापस नहीं करता है, तो हम स्वयं टोकन गिनती से इसकी गणना करते हैं।

यह छोटा लगता है। है नहीं। पाँच providers में हज़ारों requests चलाकर देखिए और अंदाज़ा लगाइए कि आपका पैसा कहाँ गया।

Structured output. हर provider JSON schema constraints का समर्थन नहीं करता। Octolib जानता है कि कौन-से करते हैं — OpenAI, Anthropic, DeepSeek, Moonshot, MiniMax — और request formatting के अंतर को संभालता है। आप response_format सेट करते हैं और parse किया हुआ JSON वापस पाते हैं। कोई manual prompt engineering नहीं। कोई "कृपया वैध JSON में जवाब दें" वाला जुगाड़ नहीं।

Embeddings और reranking. वही provider abstraction generate_embeddings() और rerank() पर भी लागू होता है। Jina, Voyage, Cohere, OpenAI, FastEmbed — एक ही API, अलग backend। आधुनिक RAG pipelines तीन अलग-अलग सेवा प्रकारों को छूते हैं। हर एक के लिए अलग clients का प्रबंधन करना ऐसा बेकार काम है जो आपको नहीं करना चाहिए।

कोई panic नहीं, कोई println नहीं। यह एक लाइब्रेरी है, app नहीं। हर public function Result लौटाता है। Errors में context होता है। Debug output stdout के बजाय tracing से होकर जाता है। ये रोमांचक फीचर्स नहीं हैं। यही फ़र्क है उस लाइब्रेरी और उस लाइब्रेरी के बीच जिस पर आप production में भरोसा करते हैं, और उस लाइब्रेरी के बीच जो आपको रात के 3 बजे जगाती है।

तीन उत्पाद, एक लाइब्रेरी

Octolib हमारे पूरे स्टैक की AI परत है:

  • Octocode — सेमांटिक कोड खोज, codebase Q&A, diff summarization
  • Octomind — agent reasoning, tool calling, multi-step workflows
  • Octobrain — ज्ञान पुनर्प्राप्ति, document processing, embedding pipelines

जब हम एक नया मॉडल जोड़ते हैं — मान लीजिए, DeepSeek का कोई reasoning मॉडल या Claude का नवीनतम रिलीज़ — तो हम Octolib को एक बार अपडेट करते हैं। हर उत्पाद उसे पा लेता है। जब OpenAI अपना API response format बदलता है या Anthropic cache pricing पेश करता है, तो फ़िक्स एक ही जगह पर रहता है।

इसीलिए हमने इसे निकाला। इसलिए नहीं कि wrapper कोड दिलचस्प है। इसलिए कि एक ही wrapper के चार संस्करण बनाए रखना महँगा है, और provider integrations को ग़लत करने का मतलब है टूटे हुए उत्पाद।

Rust का सवाल

हमसे यह कभी-कभी पूछा जाता है। संक्षिप्त उत्तर: हम बुनियादी ढाँचा Rust में बनाते हैं, और Octolib बुनियादी ढाँचा है।

लंबा उत्तर: LLM कॉल्स I/O-bound network requests हैं। लेकिन आसपास का pipeline — embedding generation, reranking, token counting, request batching, structured output validation — Rust के async प्रदर्शन और compile-time correctness के संयोजन से लाभान्वित होता है। जब आप उस पैमाने पर inference चला रहे हों जहाँ मिलीसेकंड मायने रखते हैं, तो आप अपने hot path में garbage collection pauses या runtime type errors नहीं चाहते।

और AI बुनियादी ढाँचे के लिए Rust ecosystem तेज़ी से परिपक्व हो रहा है। Local inference के लिए Candle। Async के लिए tokio। अंतहीन JSON parsing के लिए serde। सब कुछ साफ़-सुथरे ढंग से एक साथ फिट हो जाता है।

FAQ

Octolib क्या है?

Octolib LLM इन्फरेंस, embeddings और reranking के लिए एक ओपन-सोर्स Rust लाइब्रेरी है। एक API स्ट्रिंग (provider:model) कॉल्स को OpenAI, Anthropic, Google, DeepSeek, OpenRouter, Ollama और 10+ अन्य providers तक रूट करती है। यह Octocode, Octomind और Octobrain को चलाती है।

Octolib LiteLLM या LangChain से कैसे अलग है?

Octolib Rust-native है, बुनियादी ढाँचे के स्तर की है, और दायरे में संकीर्ण है। यह provider routing, structured output, लागत ट्रैकिंग और reranking संभालती है — और कुछ नहीं। कोई agents नहीं, कोई chains नहीं, कोई prompt templates नहीं। यदि आप Rust में AI फीचर्स बना रहे हैं और अपने कोड और 15+ providers के बीच एक पतली, पूर्वानुमेय परत चाहते हैं, तो यही niche है।

कौन-से providers समर्थित हैं?

15 LLM providers (OpenAI, Anthropic, Google Gemini, DeepSeek, Moonshot, MiniMax, Z.ai, OpenRouter, NVIDIA NIM, Cerebras, Together, Cloudflare Workers AI, OctoHub, Ollama, custom local endpoints) और 6 embedding/reranking providers (Jina, Voyage, Cohere, OpenAI, Google, FastEmbed)।

क्या यह स्थानीय मॉडलों के साथ काम करता है?

हाँ। Ollama और कोई भी OpenAI-compatible local endpoint बिना किसी अतिरिक्त सेटअप के काम करता है। FastEmbed बिना API के स्थानीय रूप से embeddings चलाता है। केवल provider:model स्ट्रिंग ही बदलती है।

लागत ट्रैकिंग कैसे काम करती है?

हर response में टोकन उपयोग और गणना की गई लागत शामिल होती है। Native providers प्रति-मॉडल pricing tables का उपयोग करते हैं। Aggregators मॉडल नाम से reference pricing पर fallback करते हैं। यदि upstream API एक cost field नहीं लौटाता है, तो Octolib टोकन गिनती से इसकी गणना करता है।

क्या यह production-ready है?

यह हर दिन तीन उत्पाद (Octocode, Octomind, Octobrain) चलाती है। लाइब्रेरी कोड में कोई panic नहीं। हर public function Result लौटाता है। Debug output tracing से होकर जाता है। लाइसेंस Apache-2.0 है।

ओपन सोर्स, खुला ecosystem

Octolib एक बड़ी तस्वीर का एक टुकड़ा है। Octocode ओपन सोर्स है। Octomind की वास्तुकला सार्वजनिक रूप से दस्तावेज़ित है। हम सार्वजनिक रूप से निर्माण कर रहे हैं क्योंकि जिन समस्याओं को हम हल कर रहे हैं — दस अलग-अलग AI providers से अपना दिमाग़ खोए बिना कैसे बात करें — वे केवल हमारे लिए अनोखी नहीं हैं।

लाइब्रेरी GitHub पर है। यह cargo check के साथ compile होती है। यह एक API key के अलावा बिना किसी कॉन्फ़िगरेशन के examples चलाती है। यदि आप Rust में AI फीचर्स बना रहे हैं और तीसरी बार वही provider boilerplate लिखकर थक गए हैं, तो यह आपके कुछ हफ़्ते बचा सकती है।

जैसे-जैसे चीज़ें विकसित होती हैं हम providers जोड़ते जाते हैं। अगला शायद पहले से ही किसी pull request में है।