How to Build a Local Proof-Asset Search Layer (2026)

Matt Payne·October 12, 2026·Updated October 12, 2026·8 min read

Key Takeaway

EmbeddingGemma 2 indexes decks, screenshots, videos, and call clips locally for $0 per call. Use 256 dimensions to keep 95% retrieval quality at one-third the storage. Chunk by slide or 30-second clip, store vectors in FAISS, and expose search through one permission-controlled agent tool.

Build a Local Proof-Asset Search Layer

EmbeddingGemma 2 puts text, slides, images, video, and audio in one local search index. Your files stay on your hardware instead of passing through a SaaS RAG vendor.

Google's model has 740 million parameters and no per-call fee. That makes local multimodal semantic search practical for a marketing team with thousands of private assets.

Step 1: Define What Counts as Proof

Don't index your whole shared drive.

A proof-asset search layer should contain evidence that helps marketing or sales support a claim. That includes customer quotes, product screenshots, case study slides, call clips, demo videos, charts, and approved brand assets.

Start with real questions your team asks:

"Find screenshots showing the reporting dashboard."
"Which customer clips mention onboarding?"
"Find proof that customers reduced manual work."
"Show me approved healthcare slides."
"Find a video where the product handles duplicate records."

This is different from searching filenames. Semantic search matches meaning across formats.

A query about "reducing manual work" can find a slide titled "97% fewer search rules." It can also find a call clip where a customer says, "We stopped updating redirects by hand."

Condé Nast had an earlier version of this problem. Its teams searched more than 140,000 videos using hand-written titles and descriptions.

AWS reported that multimodal search cut discovery time from 250 minutes to under two minutes. That's a vendor-published speed claim, not an accuracy score.

Card catalogs worked when the catalog was small. They broke down when content grew faster than people could tag it.

Tools and cost: Use your existing file storage and a local metadata database such as SQLite. EmbeddingGemma 2 has no per-call fee under its Apache 2.0 license.

Expected outcome: A controlled asset list tied to specific marketing and sales questions.

Step 2: Turn Every Asset Into Searchable Chunks

Bad chunking ruins good embeddings.

Don't embed a 70-slide deck as one object. Don't create one vector for a two-hour customer call, either.

Each chunk needs four things:

1. The original asset ID 2. A searchable unit 3. Enough context to understand it 4. Permission and source metadata

Use different rules for each asset type.

Decks and PDFs

Create one chunk per slide or page.

Store the extracted text and a rendered image together. The text catches exact product names. The image catches charts, screenshots, and visual layouts.

Keep this metadata:

File name
Slide number
Customer or campaign
Approval status
Expiration date
Owner
Confidentiality level

Screenshots

Embed the image directly. Add OCR text as a second record linked to the same screenshot.

Don't treat OCR as the truth. Product screenshots often contain clipped labels, tiny text, and UI elements that OCR mangles.

Videos

Split videos by scene or topic. Start with 20-to-30-second clips and five seconds of overlap.

EmbeddingGemma 2 samples video at one frame per second by default. Google's processor caps the default input at 32 frames, so giant video chunks are a bad idea.

Store the start time, end time, transcript, speaker, and usage rights.

Call clips

Convert audio to 16 kHz mono. Google's guide lists audio at about 25 tokens per second.

Start with 30-to-60-second chunks. Keep five seconds of overlap so a customer's point doesn't get cut in half.

Text and code

Start with sections of 200 to 500 words. Keep headings attached to the section beneath them.

EmbeddingGemma 2 supports an 8,192-token context window. That doesn't mean every chunk should use all 8,192 tokens.

Tools and cost: FFmpeg handles local video and audio splitting. PyMuPDF or LibreOffice can render slides and PDFs. These tools don't add embedding API fees.

Expected outcome: Small, traceable records that point back to an exact slide, screenshot, timestamp, or quote.

Step 3: Embed Locally With EmbeddingGemma 2

EmbeddingGemma 2 maps text, code, images, video, and audio into one 768-dimensional vector format.

You don't have to load all 740 million parameters.

Google says the model can load in four configurations:

Configuration	Parameters
Text and code	270M
Text and vision	440M
Text and audio	570M
Full multimodal	740M

A marketing archive usually needs the full model during indexing. A text-only query service can use the smaller 270M setup because the vectors share the same format.

Google reports about 191 MB of active RAM for text-only weights. The full quantized model uses about 567 MB on a Pixel 11 Pro.

Those aren't desktop memory promises. Google measured them on its own hardware and runtime.

Use 256 dimensions unless testing proves otherwise

The model produces 768 dimensions but supports Matryoshka truncation.

Google reports that 256 dimensions preserve most text quality and about 95% of image, video, and speech retrieval quality. That cuts vector storage by roughly two-thirds.

At 128 dimensions, multimodal quality drops more sharply. Google reports roughly 75% quality for image, video, and speech retrieval.

I wouldn't use 128 dimensions for a proof library. Missing the right customer clip costs more than a few hundred megabytes.

A 256-dimensional float32 vector uses 1,024 bytes. That's about 51 MB for 50,000 vectors or 512 MB for 500,000 vectors before index overhead.

```python import faiss import numpy as np from sentence_transformers import SentenceTransformer

MODEL_ID = "google/embeddinggemma-2" DIMENSIONS = 256

model = SentenceTransformer( MODEL_ID, truncate_dim=DIMENSIONS )

index = faiss.IndexFlatIP(DIMENSIONS) metadata = []

def embed_document(text, title="none"): value = f"title: {title} | text: {text}" vector = model.encode( [value], normalize_embeddings=True ) return np.asarray(vector, dtype="float32")

def add_document(text, record): vector = embed_document(text, record.get("title", "none")) index.add(vector) metadata.append(record)

def search(query, limit=5): query_text = f"task: search result | query: {query}" vector = model.encode( [query_text], normalize_embeddings=True ).astype("float32")

scores, ids = index.search(vector, limit)

return [ { "score": float(scores[0][position]), "asset": metadata[asset_id] } for position, asset_id in enumerate(ids[0]) if asset_id >= 0 ] ```

This example covers the local FAISS index and text queries. Use Google's official processor for images, MP4 files, and 16 kHz audio. Then add those normalized vectors to the same index.

Run bfloat16 or float32 when possible. Google's model card warns that float16 can produce damaged vectors or `NaN` values.

Tools and cost: FAISS runs locally. EmbeddingGemma 2 has a $0 per-call fee. Your machine time during indexing is the cost.

Expected outcome: One local index that matches text questions against text, images, slides, video, and audio.

Step 4: Give Agents Search, Not File Access

Your agent shouldn't crawl a shared drive whenever it needs proof.

Give it one narrow tool:

```text search_proof_assets( query, customer=None, campaign=None, asset_type=None, approval_status="approved", limit=5 ) ```

The tool should return:

Asset ID
Asset type
Relevance score
Short approved excerpt
Slide or timestamp
Source path
Usage restrictions

Keep retrieval local. Don't send the original deck, recording, or screenshot to a hosted model.

If your writing agent uses Claude, Gemini, or OpenAI, pass only approved excerpts and metadata. For sensitive summaries, use a local model.

Keeping files local doesn't prevent prompt leaks. An agent can still send a customer quote to a remote model.

Use these guardrails:

Filter by user permissions before vector search
Exclude unapproved assets by default
Log every search and asset retrieval
Block raw file uploads to remote models
Strip customer names when they aren't needed
Set expiration dates for old proof
Keep separate indexes for restricted accounts
Return citations with every result

Orange España reported more than 1,000 Gemini agents connected to internal knowledge in BigQuery and Cloud Storage. It also named an Agent Registry and Agent Gateway for control.

Build that control layer before you deploy a chatbot.

Tools and cost: A local API built with FastAPI can expose FAISS or Qdrant search. The local search path adds no embedding API charge.

Expected outcome: Agents can find approved evidence without getting open access to every customer file.

Step 5: Test Retrieval Before Anyone Trusts It

Don't judge search quality with five fun prompts.

Build a test set of at least 50 real questions. Mark the correct assets before running the test.

Track these numbers:

Correct asset in the top five
Correct customer or campaign
Incorrect restricted asset returned
Search time
No-result rate
Duplicate-result rate

Test each format separately. Then test cross-format searches.

Google says EmbeddingGemma 2 puts every format in one vector space. Text-to-audio scores may still behave differently from text-to-image scores.

S5 Labs warns that Google hasn't published calibration guidance across modalities. Its recommendation is sensible: search each modality, then merge the ranked results.

Use that pattern:

1. Search slides 2. Search screenshots 3. Search video 4. Search audio 5. Merge and rerank the top results

Run 768 dimensions as your quality baseline. Compare it with 256 dimensions on the same 50 questions.

Don't use Google's benchmark as your acceptance test. Google reports scores such as 62.9 R@1 on MSCOCO and 68.8 NDCG@10 on Vatex, but your archive isn't MSCOCO or Vatex.

West Marine measured search against sales. Salesforce reported an 8.5% conversion lift and a 97% drop in manual search rules during the first month.

Your proof layer needs a business metric, too. Track time to find evidence, approved-asset reuse, and how often agents cite the correct source.

Tools and cost: Store the test questions in a CSV or SQLite table. Run the same queries after every model, chunking, or dimension change.

Expected outcome: A search layer you can measure, fix, and trust.

FAQ

What is EmbeddingGemma 2, and can it run locally?

EmbeddingGemma 2 is Google's 740M-parameter multimodal embedding model. It runs locally and maps text, code, images, video, and audio into one 768-dimensional vector format.

How do you build privacy-first multimodal semantic search?

Process files locally, split them into format-specific chunks, and create embeddings with EmbeddingGemma 2. Store the vectors in local FAISS or Qdrant, then expose retrieval through a permission-controlled agent tool.

Can marketing teams index decks without uploading them to a SaaS RAG tool?

Yes. Render each slide locally, extract its text, embed both the slide image and text, and store the vectors on your hardware. The agent can receive approved excerpts without receiving the source deck.

How much does local multimodal semantic search cost?

EmbeddingGemma 2 has no per-call fee. Hosted Gemini video embeddings were listed at $12 per million video tokens, or $6 through batch processing. Local costs come from your hardware, storage, and maintenance.

Should I use 768, 256, or 128 embedding dimensions?

Use 768 dimensions when recall matters most. Google reports that 256 dimensions keep about 95% of image, video, and speech retrieval quality. At 128 dimensions, multimodal retrieval drops more sharply.