यदि आप हाल ही में एम्बेडिंग्स (embeddings) के साथ कुछ भी बना रहे हैं, तो आप इसके दर्द को जानते हैं। टेक्स्ट के लिए एक मॉडल। इमेज के लिए दूसरा पाइपलाइन। ऑडियो को खोजने योग्य बनाने के लिए कुछ अजीब सा वर्कअराउंड। और अगर कोई आपको PDF भेज दे? तो भगवान ही मालिक है।

गूगल ने अभी-अभी कहा कि "हम उस सब को संभाल लेंगे" वो भी सिर्फ एक सिंगल मॉडल के साथ।

Gemini Embedding 2 को 10 मार्च, 2026 को रिलीज़ किया गया था, और डेवलपर कम्युनिटी इसके लिए पहले से ही दीवानी हो रही है। यह Gemini आर्किटेक्चर पर बना पहला नेटिवली (natively) मल्टीमॉडल एम्बेडिंग मॉडल है, और यह टेक्स्ट, इमेज, वीडियो, ऑडियो, और डॉक्यूमेंट्स को एक एकीकृत एम्बेडिंग स्पेस में मैप करता है।

एक मॉडल। एक वेक्टर स्पेस। पांच मोडैलिटीज़। इस बात की गहराई को समझें।

व्यस्त डेवलपर्स के लिए संक्षेप (TL;DR)

• मॉडल: gemini-embedding-2-preview

• मोडैलिटीज़: टेक्स्ट, इमेज (PNG/JPEG), वीडियो (MP4/MOV 128 सेकेंड तक), ऑडियो (MP3/WAV 80 सेकेंड तक), PDFs (6 पेज तक)

• डाइमेंशन्स (Dimensions): 128 से 3,072 (Matryoshka Representation Learning के माध्यम से फ्लेक्सिबल)

• कॉन्टेक्स्ट विंडो (Context window): 8,192 टोकन

• भाषाएं: 100 से अधिक

• MTEB स्कोर: 67.99-68.17 (मल्टीमॉडल वेरिएंट) | Gemini Embedding 001, MTEB इंग्लिश पर 68.32 के साथ #1 स्थान पर है

• इंटीग्रेशन: LangChain, LlamaIndex, Haystack, Qdrant, Weaviate, ChromaDB, Pinecone, Vector Search

• उपलब्धता: Gemini API और Vertex AI के माध्यम से पब्लिक प्रीव्यू

आपको इसकी परवाह क्यों होनी चाहिए?

मुझे आपको एक उदाहरण देने दें।

आप अपनी कंपनी के लिए एक नॉलेज बेस बना रहे हैं। आपका डेटा स्लैक (Slack) मैसेज (टेक्स्ट), प्रोडक्ट स्क्रीनशॉट (इमेज), ऑनबोर्डिंग वीडियो (वीडियो), कस्टमर सपोर्ट कॉल (ऑडियो), और अनुपालन दस्तावेजों (PDFs) में फैला हुआ है।

Gemini Embedding 2 से पहले, आपको इनमें से प्रत्येक के लिए एक अलग मॉडल या पाइपलाइन की आवश्यकता होती थी। आप इमेज के लिए CLIP, ऑडियो ट्रांसक्रिप्शन के लिए Whisper + ट्रांसक्रिप्ट के लिए टेक्स्ट एम्बेडिंग, और अपने टेक्स्ट डॉक्यूमेंट्स के लिए एक और मॉडल के साथ किसी तरह का कामचलाऊ आर्किटेक्चर तैयार करते थे।

अब? सिर्फ एक API कॉल। सब कुछ उसी वेक्टर स्पेस में चला जाता है। आप सचमुच एक ही क्वेरी के साथ इन सभी में सर्च कर सकते हैं।

यह कोई मामूली सुधार नहीं है। यह एक बड़ा बदलाव (paradigm shift) है।

क्या चीज़ Gemini Embedding 2 को अलग बनाती है

1. नेटिवली मल्टीमॉडल (ऊपर से थोपा हुआ नहीं)

यह सबसे बड़ी बात है। Gemini Embedding 2 पहले आपके ऑडियो को टेक्स्ट में कनवर्ट नहीं करता और फिर उसे एम्बेड नहीं करता। यह आपकी इमेज को किसी अलग विज़न एनकोडर के ज़रिए नहीं चलाता। यह Gemini आर्किटेक्चर के माध्यम से नेटिवली सभी पांच मोडैलिटीज़ को प्रोसेस करता है।

इसका मतलब है:

• ऑडियो, ऑडियो के रूप में ही जाता है। कोई नुकसानदेह स्पीच-टू-टेक्स्ट स्टेप नहीं। ट्रांसक्रिप्शन में कोई जानकारी नहीं खोती।

• इमेज, इमेज के रूप में ही जाती हैं। मॉडल वही देखता है जो आप देखते हैं।

• वीडियो, वीडियो के रूप में ही जाता है। इसमें टेम्पोरल अंडरस्टैंडिंग (समय-संबंधी समझ) भी शामिल है।

• PDFs, डॉक्यूमेंट्स के रूप में ही जाते हैं। लेआउट, टेबल, आंकड़े, सब कुछ कैप्चर हो जाता है।

और आप इन्हें मिला भी सकते हैं। एक ही रिक्वेस्ट में इमेज + टेक्स्ट डिस्क्रिप्शन भेजें, और एक सिंगल एम्बेडिंग पाएं जो दोनों के बीच के संबंध को कैप्चर करती है।

2. मैत्रियोश्का रिप्रेजेंटेशन लर्निंग (MRL)

उन रूसी नेस्टिंग डॉल्स (खिलौनों) के नाम पर रखा गया, MRL आपको बिना दोबारा ट्रेनिंग दिए अपने एम्बेडिंग डाइमेंशन्स को स्केल करने की सुविधा देता है। पूरा आउटपुट 3,072 डाइमेंशन्स का है, लेकिन आप इसे घटाकर 1,536 या 768 कर सकते हैं और फिर भी ठोस सिमेंटिक क्वालिटी पा सकते हैं।

यह क्यों मायने रखता है? स्टोरेज की लागत और लेटेंसी के लिए।

• 3,072 dims: अधिकतम क्वालिटी। अपनी बेहतरीन खोज (gold-standard retrieval) के लिए इसका उपयोग करें।

• 1,536 dims: बढ़िया संतुलन। अधिकांश प्रोडक्शन सिस्टम यहीं काम करेंगे।

• 768 dims: तेज़, सस्ता, और फिर भी आश्चर्यजनक रूप से अच्छा। शुरुआती कैंडिडेट खोज के लिए बिल्कुल सही।

प्रो टिप: दो-पास रिट्रीवल सिस्टम चलाएं। स्पीड के लिए पहला पास 768 dims पर, फिर सटीकता के लिए पूरे 3,072 dims के साथ टॉप-K परिणामों को री-स्कोर करें। इस रणनीति पर Qdrant का ब्लॉग इसे अच्छे से समझाता है।

3. नेटिव ऑडियो एम्बेडिंग (यह वॉयस AI के लिए बहुत बड़ी बात है)

यदि आप वॉयस AI स्पेस में हैं, तो ध्यान दें।

अधिकांश एम्बेडिंग मॉडल ऑडियो को पूरी तरह से अनदेखा कर देते हैं। आपको पहले ट्रांसक्राइब करना पड़ता था, जिससे स्वर-शैली (prosody), टोन और वक्ता की विशेषताएं खो जाती थीं, और फिर उस साधारण टेक्स्ट को एम्बेड करना पड़ता था।

Gemini Embedding 2 ऑडियो को सीधे एम्बेड करता है। MP3, WAV, प्रति क्लिप 80 सेकंड तक।

सोचिए इससे क्या रास्ते खुलते हैं:

• पॉडकास्ट सर्च: सिर्फ ट्रांसक्रिप्ट कीवर्ड्स से ही नहीं, बल्कि अर्थ के आधार पर सेगमेंट खोजें

• कस्टमर कॉल एनालिटिक्स: हजारों घंटों की कॉल्स में सिमेंटिक सर्च

• वॉयस नोट रिट्रीवल: "वह रिकॉर्डिंग ढूंढो जहां मैंने Q3 बजट के बारे में बात की थी"

• म्यूज़िक सिमिलैरिटी: ऑडियो को एम्बेड करें और सिमेंटिक रूप से समान ट्रैक खोजें

वॉयस AI प्रोडक्ट्स बनाने वाली कंपनियों के लिए, यह सिस्टम से जटिलता की एक पूरी परत को हटा देता है।

4. इंटरलीव्ड मल्टीमॉडल इनपुट्स

यह एक ऐसा फीचर है जिस पर अधिकांश लोग ध्यान नहीं दे रहे हैं।

आप एक एकल (single) कंटेंट एंट्री में कई मोडैलिटीज़ भेज सकते हैं, और मॉडल एक एग्रीगेटेड एम्बेडिंग तैयार करता है जो उनके बीच के संबंधों को कैप्चर करती है। इमेज + कैप्शन? वीडियो + डिस्क्रिप्शन? ऑडियो क्लिप + ट्रांसक्रिप्ट? सब कुछ एक ही एम्बेडिंग में।

वास्तविक दुनिया का डेटा इसी तरह काम करता है। कोई प्रोडक्ट लिस्टिंग केवल टेक्स्ट या केवल इमेज नहीं होती। यह दोनों होती है। और अब आपकी एम्बेडिंग्स इसे दर्शा सकती हैं।

बेंचमार्क: यह वास्तव में कहाँ ठहरता है?

आइए आंकड़ों पर बात करते हैं। यहाँ मार्च 2026 की MTEB लीडरबोर्ड है:

पुराने MTEB (56 टास्क) से स्कोर। क्रॉस-लीडरबोर्ड तुलना अनुमानित है।

स्रोत: MTEB Embedding Model Leaderboard, March 2026

कुछ चीज़ें तुरंत ध्यान खींचती हैं:

Google का Gemini Embedding 001 नए इंग्लिश MTEB लीडरबोर्ड पर #1 स्थान पर है जिसका औसत 68.32 है। और Gemini Embedding 2 (मल्टीमॉडल वर्शन) अपने डाइमेंशन टियर्स में 67.99-68.17 स्कोर करता है। वह भी मल्टीमॉडल सपोर्ट के साथ, जो अन्य टॉप मॉडल्स में से किसी के पास नहीं है।

विशेष रूप से रिट्रीवल (खोजने) पर, जिसकी हममें से अधिकांश को वास्तव में RAG के लिए परवाह होती है, Gemini Embedding 001, 67.71 स्कोर करता है। इसकी तुलना 62.65 पर NV-Embed-v2 से करें। यदि रिट्रीवल आपका प्राथमिक उपयोग का मामला है, तो Google की बढ़त और भी अधिक महत्वपूर्ण है।

कीमत की कहानी कमाल की है। लगभग $0.004 प्रति 1K वर्णों पर, Gemini Embedding, OpenAI ($0.13/1M टोकन) और Cohere ($0.12/1M टोकन) की तुलना में काफी सस्ता है। और वे ओपन-सोर्स मॉडल्स जो अधिक स्कोर करते हैं? उनके लिए आपको अपने खुद के इंफ्रास्ट्रक्चर को होस्ट और स्केल करना होगा।

मुझे कोड दिखाएं

सिद्धांत बहुत हुआ। आइए अब कुछ बनाते हैं।

बेसिक: टेक्स्ट एम्बेडिंग

from google import genai
from google.genai import types
<p>client = genai.Client()</p>
<h1>सरल टेक्स्ट एम्बेडिंग</h1>
<p>result = client.models.embed_content(<br>model="gemini-embedding-2-preview",<br>contents="What is retrieval augmented generation?",<br>config=types.EmbedContentConfig(<br>task_type="RETRIEVAL_DOCUMENT",<br>output_dimensionality=768  # MRL: स्पीड के लिए छोटा करें<br>)<br>)</p>

from google import genai
from google.genai import types
<p>client = genai.Client()</p>
<h1>सरल टेक्स्ट एम्बेडिंग</h1>
<p>result = client.models.embed_content(<br>model="gemini-embedding-2-preview",<br>contents="What is retrieval augmented generation?",<br>config=types.EmbedContentConfig(<br>task_type="RETRIEVAL_DOCUMENT",<br>output_dimensionality=768  # MRL: स्पीड के लिए छोटा करें<br>)<br>)</p>

from google import genai
from google.genai import types
<p>client = genai.Client()</p>
<h1>सरल टेक्स्ट एम्बेडिंग</h1>
<p>result = client.models.embed_content(<br>model="gemini-embedding-2-preview",<br>contents="What is retrieval augmented generation?",<br>config=types.EmbedContentConfig(<br>task_type="RETRIEVAL_DOCUMENT",<br>output_dimensionality=768  # MRL: स्पीड के लिए छोटा करें<br>)<br>)</p>

मल्टीमॉडल: एक ही बार में टेक्स्ट + इमेज + ऑडियो

यह वह जगह है जहां चीजें बहुत रोमांचक हो जाती हैं।

from google import genai<br>from google.genai import types<p></p>
<p>client = genai.Client()</p>
<h1>अपना मल्टीमॉडल डेटा लोड करें</h1>
<p>with open("product_photo.png", "rb") as f:<br>image_bytes = f.read()</p>
<p>with open("customer_review.mp3", "rb") as f:<br>audio_bytes = f.read()</p>
<h1>एक API कॉल। तीन मोडैलिटीज़। एक एम्बेडिंग।</h1>
<p>result = client.models.embed_content(<br>model="gemini-embedding-2-preview",<br>contents=[<br>"Premium wireless headphones with noise cancellation",<br>types.Part.from_bytes(<br>data=image_bytes,<br>mime_type="image/png",<br>),<br>types.Part.from_bytes(<br>data=audio_bytes,<br>mime_type="audio/mpeg",<br>),<br>],<br>)</p

from google import genai<br>from google.genai import types<p></p>
<p>client = genai.Client()</p>
<h1>अपना मल्टीमॉडल डेटा लोड करें</h1>
<p>with open("product_photo.png", "rb") as f:<br>image_bytes = f.read()</p>
<p>with open("customer_review.mp3", "rb") as f:<br>audio_bytes = f.read()</p>
<h1>एक API कॉल। तीन मोडैलिटीज़। एक एम्बेडिंग।</h1>
<p>result = client.models.embed_content(<br>model="gemini-embedding-2-preview",<br>contents=[<br>"Premium wireless headphones with noise cancellation",<br>types.Part.from_bytes(<br>data=image_bytes,<br>mime_type="image/png",<br>),<br>types.Part.from_bytes(<br>data=audio_bytes,<br>mime_type="audio/mpeg",<br>),<br>],<br>)</p

from google import genai<br>from google.genai import types<p></p>
<p>client = genai.Client()</p>
<h1>अपना मल्टीमॉडल डेटा लोड करें</h1>
<p>with open("product_photo.png", "rb") as f:<br>image_bytes = f.read()</p>
<p>with open("customer_review.mp3", "rb") as f:<br>audio_bytes = f.read()</p>
<h1>एक API कॉल। तीन मोडैलिटीज़। एक एम्बेडिंग।</h1>
<p>result = client.models.embed_content(<br>model="gemini-embedding-2-preview",<br>contents=[<br>"Premium wireless headphones with noise cancellation",<br>types.Part.from_bytes(<br>data=image_bytes,<br>mime_type="image/png",<br>),<br>types.Part.from_bytes(<br>data=audio_bytes,<br>mime_type="audio/mpeg",<br>),<br>],<br>)</p

तीन मोडैलिटीज़। एक वेक्टर। आपके डेटाबेस की अन्य सभी चीजों की तरह ही समान एम्बेडिंग स्पेस।

क्रॉस-मोडल सर्च: टेक्स्ट क्वेरी करें, इमेज पाएं

import numpy as np<br>from google import genai<br>from google.genai import types<p></p>
<p>client = genai.Client()</p>
<p>def get_embedding(content, task_type="RETRIEVAL_DOCUMENT"):<br>result = client.models.embed_content(<br>model="gemini-embedding-2-preview",<br>contents=content,<br>config=types.EmbedContentConfig(task_type=task_type)<br>)<br>return np.array(result.embeddings[0].values)</p>
<p>def cosine_similarity(a, b):<br>return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))</p>
<h1>कुछ इमेजेस को एम्बेड करें</h1>
<p>image_embeddings = []<br>image_files = ["sunset.jpg", "coffee_shop.jpg", "mountain.jpg", "beach.jpg"]</p>
<p>for img_file in image_files:<br>with open(img_file, "rb") as f:<br>img_data = f.read()<br>emb = get_embedding(<br>types.Part.from_bytes(data=img_data, mime_type="image/jpeg")<br>)<br>image_embeddings.append((img_file, emb))</p>
<h1>अब TEXT के साथ सर्च करें</h1>
<p>query_emb = get_embedding(<br>"a relaxing place to have coffee",<br>task_type="RETRIEVAL_QUERY"<br>)</p>
<h1>टेक्स्ट क्वेरी के साथ समानता के आधार पर इमेजेस को रैंक करें</h1>
<p>results = []<br>for name, emb in image_embeddings:<br>sim = cosine_similarity(query_emb, emb)<br>results.append((name, sim))</p

import numpy as np<br>from google import genai<br>from google.genai import types<p></p>
<p>client = genai.Client()</p>
<p>def get_embedding(content, task_type="RETRIEVAL_DOCUMENT"):<br>result = client.models.embed_content(<br>model="gemini-embedding-2-preview",<br>contents=content,<br>config=types.EmbedContentConfig(task_type=task_type)<br>)<br>return np.array(result.embeddings[0].values)</p>
<p>def cosine_similarity(a, b):<br>return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))</p>
<h1>कुछ इमेजेस को एम्बेड करें</h1>
<p>image_embeddings = []<br>image_files = ["sunset.jpg", "coffee_shop.jpg", "mountain.jpg", "beach.jpg"]</p>
<p>for img_file in image_files:<br>with open(img_file, "rb") as f:<br>img_data = f.read()<br>emb = get_embedding(<br>types.Part.from_bytes(data=img_data, mime_type="image/jpeg")<br>)<br>image_embeddings.append((img_file, emb))</p>
<h1>अब TEXT के साथ सर्च करें</h1>
<p>query_emb = get_embedding(<br>"a relaxing place to have coffee",<br>task_type="RETRIEVAL_QUERY"<br>)</p>
<h1>टेक्स्ट क्वेरी के साथ समानता के आधार पर इमेजेस को रैंक करें</h1>
<p>results = []<br>for name, emb in image_embeddings:<br>sim = cosine_similarity(query_emb, emb)<br>results.append((name, sim))</p

import numpy as np<br>from google import genai<br>from google.genai import types<p></p>
<p>client = genai.Client()</p>
<p>def get_embedding(content, task_type="RETRIEVAL_DOCUMENT"):<br>result = client.models.embed_content(<br>model="gemini-embedding-2-preview",<br>contents=content,<br>config=types.EmbedContentConfig(task_type=task_type)<br>)<br>return np.array(result.embeddings[0].values)</p>
<p>def cosine_similarity(a, b):<br>return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))</p>
<h1>कुछ इमेजेस को एम्बेड करें</h1>
<p>image_embeddings = []<br>image_files = ["sunset.jpg", "coffee_shop.jpg", "mountain.jpg", "beach.jpg"]</p>
<p>for img_file in image_files:<br>with open(img_file, "rb") as f:<br>img_data = f.read()<br>emb = get_embedding(<br>types.Part.from_bytes(data=img_data, mime_type="image/jpeg")<br>)<br>image_embeddings.append((img_file, emb))</p>
<h1>अब TEXT के साथ सर्च करें</h1>
<p>query_emb = get_embedding(<br>"a relaxing place to have coffee",<br>task_type="RETRIEVAL_QUERY"<br>)</p>
<h1>टेक्स्ट क्वेरी के साथ समानता के आधार पर इमेजेस को रैंक करें</h1>
<p>results = []<br>for name, emb in image_embeddings:<br>sim = cosine_similarity(query_emb, emb)<br>results.append((name, sim))</p

आपने टेक्स्ट टाइप किया। इसने सबसे प्रासंगिक इमेज ढूंढ ली। कोई CLIP नहीं। कोई अलग मॉडल नहीं। सिर्फ Gemini Embedding 2।

प्रोडक्शन RAG: LangChain + Qdrant

from langchain_google_genai import GoogleGenerativeAIEmbeddings<br>from langchain_qdrant import QdrantVectorStore<br>from langchain.text_splitter import RecursiveCharacterTextSplitter<br>from langchain_community.document_loaders import PyPDFLoader<p></p>
<h1>Gemini Embedding 2 को इनिशियलाइज़ करें</h1>
<p>embeddings = GoogleGenerativeAIEmbeddings(<br>model="gemini-embedding-2-preview",<br>task_type="RETRIEVAL_DOCUMENT",<br>output_dimensionality=1536  # प्रोडक्शन के लिए बैलेंस्ड डाइमेंशन्स<br>)</p>
<h1>डॉक्यूमेंट्स लोड करें और उनके टुकड़े (chunk) करें</h1>
<p>loader = PyPDFLoader("company_handbook.pdf")<br>docs = loader.load()<br>splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)<br>chunks = splitter.split_documents(docs)</p>
<h1>Qdrant में स्टोर करें</h1>
<p>vectorstore = QdrantVectorStore.from_documents(<br>documents=chunks,<br>embedding=embeddings,<br>collection_name="company_docs",<br>url="<a href="http://localhost:6333" data-framer-link="Link:{"url":"http://localhost:6333","type":"url"}">http://localhost:6333</a>",<br>)</p>
<h1>सर्च करें</h1>

from langchain_google_genai import GoogleGenerativeAIEmbeddings<br>from langchain_qdrant import QdrantVectorStore<br>from langchain.text_splitter import RecursiveCharacterTextSplitter<br>from langchain_community.document_loaders import PyPDFLoader<p></p>
<h1>Gemini Embedding 2 को इनिशियलाइज़ करें</h1>
<p>embeddings = GoogleGenerativeAIEmbeddings(<br>model="gemini-embedding-2-preview",<br>task_type="RETRIEVAL_DOCUMENT",<br>output_dimensionality=1536  # प्रोडक्शन के लिए बैलेंस्ड डाइमेंशन्स<br>)</p>
<h1>डॉक्यूमेंट्स लोड करें और उनके टुकड़े (chunk) करें</h1>
<p>loader = PyPDFLoader("company_handbook.pdf")<br>docs = loader.load()<br>splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)<br>chunks = splitter.split_documents(docs)</p>
<h1>Qdrant में स्टोर करें</h1>
<p>vectorstore = QdrantVectorStore.from_documents(<br>documents=chunks,<br>embedding=embeddings,<br>collection_name="company_docs",<br>url="<a href="http://localhost:6333" data-framer-link="Link:{"url":"http://localhost:6333","type":"url"}">http://localhost:6333</a>",<br>)</p>
<h1>सर्च करें</h1>

from langchain_google_genai import GoogleGenerativeAIEmbeddings<br>from langchain_qdrant import QdrantVectorStore<br>from langchain.text_splitter import RecursiveCharacterTextSplitter<br>from langchain_community.document_loaders import PyPDFLoader<p></p>
<h1>Gemini Embedding 2 को इनिशियलाइज़ करें</h1>
<p>embeddings = GoogleGenerativeAIEmbeddings(<br>model="gemini-embedding-2-preview",<br>task_type="RETRIEVAL_DOCUMENT",<br>output_dimensionality=1536  # प्रोडक्शन के लिए बैलेंस्ड डाइमेंशन्स<br>)</p>
<h1>डॉक्यूमेंट्स लोड करें और उनके टुकड़े (chunk) करें</h1>
<p>loader = PyPDFLoader("company_handbook.pdf")<br>docs = loader.load()<br>splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)<br>chunks = splitter.split_documents(docs)</p>
<h1>Qdrant में स्टोर करें</h1>
<p>vectorstore = QdrantVectorStore.from_documents(<br>documents=chunks,<br>embedding=embeddings,<br>collection_name="company_docs",<br>url="<a href="http://localhost:6333" data-framer-link="Link:{"url":"http://localhost:6333","type":"url"}">http://localhost:6333</a>",<br>)</p>
<h1>सर्च करें</h1>

ऑडियो नॉलेज बेस: खोजने योग्य वॉयस नोट्स

यह उदाहरण LlamaIndex के audio-kb प्रोजेक्ट से प्रेरित है जो आपकी ऑडियो रिकॉर्डिंग्स को खोजने योग्य बनाने के लिए Gemini Embedding 2 का उपयोग करता है।

from llama_index.embeddings.google_genai import GoogleGenAIEmbedding<br>from llama_index.core.node_parser import TokenTextSplitter<br>import asyncio<p></p>
<h1>इनिशियलाइज़ करें</h1>
<p>embedding_model = GoogleGenAIEmbedding(<br>model_name="gemini-embedding-2-preview"<br>)</p>
<p>splitter = TokenTextSplitter(chunk_size=512, chunk_overlap=50)</p>
<p>async def embed_audio_transcript(transcript: str):<br>"""ट्रांसक्राइब की गई ऑडियो फाइल के टुकड़े करें और एम्बेड करें।"""<br>chunks = splitter.split_text(transcript)<br>semaphore = asyncio.Semaphore(10)  # रेट लिमिट्स का ध्यान रखें</p>
<pre><code>async def get_embedding(chunk):
    async with semaphore:
        return await embedding_model.aget_text_embedding(chunk)

embeddings = await asyncio.gather(
    *[get_embedding(chunk) for chunk in chunks]
)
return list(zip(chunks, embeddings))
</code></pre

from llama_index.embeddings.google_genai import GoogleGenAIEmbedding<br>from llama_index.core.node_parser import TokenTextSplitter<br>import asyncio<p></p>
<h1>इनिशियलाइज़ करें</h1>
<p>embedding_model = GoogleGenAIEmbedding(<br>model_name="gemini-embedding-2-preview"<br>)</p>
<p>splitter = TokenTextSplitter(chunk_size=512, chunk_overlap=50)</p>
<p>async def embed_audio_transcript(transcript: str):<br>"""ट्रांसक्राइब की गई ऑडियो फाइल के टुकड़े करें और एम्बेड करें।"""<br>chunks = splitter.split_text(transcript)<br>semaphore = asyncio.Semaphore(10)  # रेट लिमिट्स का ध्यान रखें</p>
<pre><code>async def get_embedding(chunk):
    async with semaphore:
        return await embedding_model.aget_text_embedding(chunk)

embeddings = await asyncio.gather(
    *[get_embedding(chunk) for chunk in chunks]
)
return list(zip(chunks, embeddings))
</code></pre

from llama_index.embeddings.google_genai import GoogleGenAIEmbedding<br>from llama_index.core.node_parser import TokenTextSplitter<br>import asyncio<p></p>
<h1>इनिशियलाइज़ करें</h1>
<p>embedding_model = GoogleGenAIEmbedding(<br>model_name="gemini-embedding-2-preview"<br>)</p>
<p>splitter = TokenTextSplitter(chunk_size=512, chunk_overlap=50)</p>
<p>async def embed_audio_transcript(transcript: str):<br>"""ट्रांसक्राइब की गई ऑडियो फाइल के टुकड़े करें और एम्बेड करें।"""<br>chunks = splitter.split_text(transcript)<br>semaphore = asyncio.Semaphore(10)  # रेट लिमिट्स का ध्यान रखें</p>
<pre><code>async def get_embedding(chunk):
    async with semaphore:
        return await embedding_model.aget_text_embedding(chunk)

embeddings = await asyncio.gather(
    *[get_embedding(chunk) for chunk in chunks]
)
return list(zip(chunks, embeddings))
</code></pre

पूरा audio-kb टूल इंस्टॉल करें:

uv tool install git+<a href="https://github.com/run-llama/audio-kb" data-framer-link="Link:{"url":"https://github.com/run-llama/audio-kb","type":"url"}">https://github.com/run-llama/audio-kb</a><br>audio-kb process --file meeting_notes.mp3<br>audio-kb search "लॉन्च की तारीख के बारे में हमने क्या फैसला किया?"

uv tool install git+<a href="https://github.com/run-llama/audio-kb" data-framer-link="Link:{"url":"https://github.com/run-llama/audio-kb","type":"url"}">https://github.com/run-llama/audio-kb</a><br>audio-kb process --file meeting_notes.mp3<br>audio-kb search "लॉन्च की तारीख के बारे में हमने क्या फैसला किया?"

uv tool install git+<a href="https://github.com/run-llama/audio-kb" data-framer-link="Link:{"url":"https://github.com/run-llama/audio-kb","type":"url"}">https://github.com/run-llama/audio-kb</a><br>audio-kb process --file meeting_notes.mp3<br>audio-kb search "लॉन्च की तारीख के बारे में हमने क्या फैसला किया?"

टास्क के प्रकार (Task Types): सही प्रकार चुनें

Gemini Embedding 2 विशेष टास्क प्रकारों का समर्थन करता है जो आपके विशिष्ट उपयोग के मामले के लिए एम्बेडिंग को ऑप्टिमाइज़ करते हैं:

इसे न छोड़ें। सही टास्क प्रकार का उपयोग करने से आपकी रिट्रीवल क्वालिटी में काफी सुधार हो सकता है। इंडेक्स करते समय RETRIEVAL_DOCUMENT और सर्च करते समय RETRIEVAL_QUERY का उपयोग करें। यह एक छोटा सा विवरण है जो बड़ा अंतर पैदा करता है।

डेवलपर कम्युनिटी काफी उत्साहित है

इसकी घोषणाएं 10 मार्च को X (ट्विटर) पर आईं और प्रतिक्रियाएं बहुत तेजी से देखने को मिलीं।

Google AI की ओर से DEV Community पोस्ट को भी अच्छी प्रतिक्रिया मिल रही है। और Qdrant ने घोषणा के कुछ ही घंटों के भीतर एक इंटीग्रेशन गाइड भी जारी कर दी है।

वॉयस AI का दृष्टिकोण

मैं वॉयस AI में काम करता हूँ। मैं हर दिन स्पीच पाइपलाइन्स के साथ चीजें बनाता हूँ। इसलिए जब मैंने Gemini Embedding 2 की घोषणा में "नेटिव ऑडियो एम्बेडिंग" देखा, तो मैं रुक गया।

यहाँ जानिए क्यों।

यदि आपने कभी ऐसा कुछ बनाया है जिसमें वॉयस डेटा को सर्च करने, पुनः प्राप्त करने या वर्गीकृत करने की आवश्यकता होती है, तो आप इसकी प्रक्रिया को जानते हैं। आपकी पाइपलाइन कुछ इस तरह दिखती है:

ऑडियो -> स्पीच-टू-टेक्स्ट -> टेक्स्ट एम्बेडिंग -> वेक्टर DB -> सर्च

ऑडियो -> स्पीच-टू-टेक्स्ट -> टेक्स्ट एम्बेडिंग -> वेक्टर DB -> सर्च

ऑडियो -> स्पीच-टू-टेक्स्ट -> टेक्स्ट एम्बेडिंग -> वेक्टर DB -> सर्च

हर कदम लेटेंसी बढ़ाता है। हर कदम पर गलती की गुंजाइश होती है। और बीच का वह स्पीच-टू-टेक्स्ट स्टेप? वही सबसे बड़ा अवरोध (bottleneck) है। केवल गति में ही नहीं, बल्कि जानकारी के नुकसान (information loss) में भी। जैसे ही आप ट्रांसक्राइब करते हैं, आप टोन, जोर, गति, वक्ता की विशेषताएं और इमोशनल कॉन्टेक्स्ट को खो देते हैं। आपके पास केवल सपाट टेक्स्ट रह जाता है जो शायद ही यह कैप्चर कर पाता है कि वास्तव में क्या बात की गई थी।

और यदि वह ऑडियो हिंग्लिश में है? या कोड-स्विचिंग के साथ तमिल में? या किसी शोर-शराबे वाले कॉल सेंटर से आए लहजे वाली अंग्रेजी में? STT इसे बिगाड़ देता है, और आगे की सारी प्रक्रिया खराब हो जाती है। आपकी एम्बेडिंग्स केवल ट्रांसक्रिप्ट जितनी ही अच्छी होती हैं, और ट्रांसक्रिप्ट अक्सर बेकार होती है।

Gemini Embedding 2 के साथ, वह पूरी बीच की परत गायब हो जाती है:

ऑडियो -> एम्बेडिंग -> वेक्टर DB -> सर्च

ऑडियो -> एम्बेडिंग -> वेक्टर DB -> सर्च

ऑडियो -> एम्बेडिंग -> वेक्टर DB -> सर्च

ऑडियो अंदर जाता है। एम्बेडिंग बाहर आती है। कोई ट्रांसक्रिप्शन नहीं। कोई जानकारी का नुकसान नहीं। कोई STT निर्भरता नहीं।

जैसे ही मैंने इसे देखा, मेरा दिमाग उन सभी दर्दनाक पाइपलाइनों के बारे में सोचने लगा जिन पर मैंने काम किया है:

• कॉल सेंटर सर्च: ग्राहकों की कॉल्स के हजारों घंटे। अभी आप सब कुछ ट्रांसक्राइब करते हैं, प्रार्थना करते हैं कि STT लहजे को संभाल ले, और फिर टेक्स्ट सर्च करते हैं। नेटिव ऑडियो एम्बेडिंग के साथ, आप उस सब को छोड़ देते हैं और सीधे अर्थ के आधार पर ऑडियो सर्च करते हैं।

• बहुभाषी वॉयस रिट्रीवल: यह मॉडल 100 से अधिक भाषाओं का समर्थन करता है। आप एक हिंदी ऑडियो क्लिप को एम्बेड कर सकते हैं और इसे अंग्रेजी टेक्स्ट क्वेरी से प्राप्त कर सकते हैं। सोचिए बहुभाषी बाजारों में सेवा देने वाली कंपनियों के लिए इसके क्या मायने हैं। केवल अपनी सामग्री को खोजने योग्य बनाने के लिए प्रति भाषा अलग STT मॉडल बनाए रखने की आवश्यकता नहीं है।

• वॉयस नोट रिट्रीवल: "वह रिकॉर्डिंग ढूंढो जहां मैंने क्लाइंट के साथ प्राइसिंग पर चर्चा की थी।" वह क्वेरी, टेक्स्ट के रूप में, बिना क्लिप को ट्रांसक्राइब किए सही ऑडियो क्लिप ढूंढ लेती है। यही इसका वादा है।

• उन चीजों को सहेजना जिन्हें शब्द कैप्चर नहीं कर सकते: व्यंग्य, हताशा, तात्कालिकता। एक ग्राहक का सपाट लहजे में "बहुत बढ़िया, धन्यवाद" कहना, उत्साहपूर्वक कहने से बहुत अलग होता है। ट्रांसक्रिप्ट्स इसे खो देते हैं। ऑडियो एम्बेडिंग्स शायद इसे न खोएं।

क्या यह आज इन सभी चीजों के लिए पूरी तरह तैयार है? ईमानदारी से कहूं तो, मुझे अभी तक नहीं पता। लंबे कॉल्स के लिए 80 सेकंड की ऑडियो सीमा एक बाधा है। और किसी भी मौजूदा पाइपलाइन को बदलने से पहले मैं यह देखना चाहता हूँ कि यह वास्तविक दुनिया के शोर वाले ऑडियो को कैसे संभालता है।

लेकिन दिशा बिल्कुल स्पष्ट है। वॉयस AI के लिए "पहले ट्रांसक्राइब करें, बाद में एम्बेड करें" का समय अब खत्म होने वाला है। और यदि आप स्पीच डेटा के साथ कुछ भी बना रहे हैं, तो यह सुविधा अभी आपके ध्यान में होनी चाहिए।

इंटीग्रेशन इकोसिस्टम: पहले दिन से ही तैयार

Google ने इसे अकेले लॉन्च नहीं किया। पहले दिन से ही Gemini Embedding 2 का इन ऐप्स के साथ इंटीग्रेशन उपलब्ध है:

• LangChain: GoogleGenerativeAIEmbeddings

• LlamaIndex: GoogleGenAIEmbedding

• Qdrant: हाइब्रिड सर्च के लिए नाम वाले वेक्टर्स के साथ नेटिव सपोर्ट

• Weaviate: डायरेक्ट इंटीग्रेशन

• ChromaDB: बिना किसी अतिरिक्त सेटिंग के काम करता है

• Pinecone: सर्वरलेस वेक्टर सर्च

• Google Vector Search: BigQuery, AlloyDB, Cloud SQL

साथ ही Google AI Studio में एक लाइव डेमो ऐप भी है जहाँ आप रीयल-टाइम में मल्टीमॉडल सर्च को काम करते हुए देख सकते हैं। पैट्रिक लोएबर ने इसे लॉन्च के दिन शेयर किया था।

महत्वपूर्ण माइग्रेशन नोट

यदि आप पहले से ही gemini-embedding-001 का उपयोग कर रहे हैं, तो ध्यान दें: एम्बेडिंग स्पेस आपस में इनकम्पैटिबल (असंगत) हैं। आप एक ही वेक्टर स्टोर में दोनों मॉडल्स के एम्बेडिंग्स को मिक्स नहीं कर सकते। जब आप स्विच करेंगे, तो आपको अपने मौजूदा डेटा को फिर से एम्बेड करना होगा।

इसके लिए पहले से योजना बनाएं। यह केवल "मॉडल का नाम बदलने और काम शुरू करने" जैसी स्थिति नहीं है।

क्विक स्टार्ट: 5 मिनट में एम्बेडिंग्स तैयार करें

from google import genai<p></p>
<p>client = genai.Client()</p>
<h1>बस हो गया। आप तैयार हैं।</h1>
<p>result = client.models.embed_content(<br>model="gemini-embedding-2-preview",<br>contents="अपना टेक्स्ट, इमेज, ऑडियो, वीडियो, या PDF यहाँ डालें"<br>)</p

from google import genai<p></p>
<p>client = genai.Client()</p>
<h1>बस हो गया। आप तैयार हैं।</h1>
<p>result = client.models.embed_content(<br>model="gemini-embedding-2-preview",<br>contents="अपना टेक्स्ट, इमेज, ऑडियो, वीडियो, या PDF यहाँ डालें"<br>)</p

from google import genai<p></p>
<p>client = genai.Client()</p>
<h1>बस हो गया। आप तैयार हैं।</h1>
<p>result = client.models.embed_content(<br>model="gemini-embedding-2-preview",<br>contents="अपना टेक्स्ट, इमेज, ऑडियो, वीडियो, या PDF यहाँ डालें"<br>)</p

अपनी API की (key) Google AI Studio से प्राप्त करें और काम शुरू करें।

मेरा नज़रिया

मैं पिछले कुछ समय से एम्बेडिंग मॉडल्स के साथ काम कर रहा हूँ। केवल-टेक्स्ट से एक ही मॉडल में वास्तव में मल्टीमॉडल एम्बेडिंग पर जाना एक बहुत बड़ा कदम है। यह केवल "अरे वाह, एक नया मॉडल आया है" जैसा नहीं है। बल्कि यह "इससे बदल जाता है कि कौन से आर्किटेक्चर संभव हैं" जैसा बड़ा बदलाव है।

यह तथ्य कि अब आप यह कर सकते हैं:

1. एक कस्टमर सपोर्ट कॉल (ऑडियो) लें

2. बिना ट्रांसक्रिप्शन के इसे सीधे एम्बेड करें

3. इसे प्रोडक्ट डॉक्स (PDF), स्क्रीनशॉट (इमेज), और नॉलेज बेस आर्टिकल्स (टेक्स्ट) के साथ स्टोर करें

4. एक सिंगल टेक्स्ट क्वेरी के साथ इन सब में सर्च करें

...और यह सब आसानी से काम करता है क्योंकि सब कुछ एक ही वेक्टर स्पेस में रहता है? यह पहले हमारे पास मौजूद टूल्स की तुलना में मौलिक रूप से एक अलग और बेहतर बिल्डिंग ब्लॉक है।

क्या यह एकदम परफेक्ट है? नहीं। यह अभी भी प्रीव्यू में है। 80 सेकंड की ऑडियो सीमा और 6 पेज की PDF सीमा कुछ उपयोग के मामलों के लिए बाधा होगी। और अपने वर्तमान एम्बेडिंग सेटअप से माइग्रेशन करने से पहले आप अपने विशिष्ट डेटा पर इसका पूरी तरह से परीक्षण करना चाहेंगे।

लेकिन दिशा बिल्कुल स्पष्ट है। मल्टीमॉडल एम्बेडिंग्स ही रिट्रीवल का भविष्य हैं। और Google ने इसे API की रखने वाले हर डेवलपर के लिए सुलभ बना दिया है।

जाएं और इसके साथ कुछ बेहतरीन बनाएं।

संसाधन (Resources)

• आधिकारिक गूगल ब्लॉग: Gemini Embedding 2

• Gemini Embedding API डॉक्यूमेंटेशन

• मॉडल कार्ड: gemini-embedding-2-preview

• DEV Community पर Google AI

• Qdrant + Gemini Embedding 2 गाइड

• LlamaIndex ऑडियो नॉलेज बेस ट्यूटोरियल

• MTEB लीडरबोर्ड (मार्च 2026)

• Google AI Studio