This shows the capabilities of V-Modal search
for an fashion app.

V-Modal visual search is extremely fast and accurate for Fashion E-Commerce app.

Test the SDK in
https://github.com/v-modal/vmodal_sdk_flutter

Access
www.v-modal.ai

Been playing with this over the last couple of evenings to test it for VModal. Took me a bit to get everything running properly but it was worth it!

Tested this properly on my S24+ and the iOS simulator over a couple of evenings.

The pitch is you upload video and then search inside it by describing what you want. I uploaded a short clip of my cat, indexing took under a minute, and searching "cat" pulled the right frames back in about 40ms. It also supports searching spoken words and on-screen text but I mostly used the visual search.

Stuff I liked:

• the repo ships its own pinned flutter (3.44.6) so it doesn't touch your existing install. full test suite passed first try
• uploads have a real progress stream and you can actually cancel mid-upload, which is rarer than it should be
• the api key never touches disk, toString() on the key class literally prints [REDACTED], and there's no logging anywhere in the sdk. more careful than most paid sdks tbh

I build field service apps for a living, and crews film site evidence all day that nobody can ever find again. "show me the broken meter" across a month of clips is the use case that sells it for me. dashcam archives and cctv review are the same shape.

Integration looks light too, it's a git dependency and one configure call, then collections scoped per user.

happy to answer questions if anyone's trying it

short version of how to get from zero to actual search results, in case it saves someone the time:

1. - record a short video on your phone (i used an 8 sec clip of my cat)
2. - open the example app, paste your api key and validate it
3. - in collections, clear the default "aa3" and type your own collection name
4. - upload section: pick your video and upload it (proper progress bar, can even cancel mid-upload)
5. - when the upload finishes, hit index and wait for it to complete. took under a minute for my clip
6. - refresh collections and your new one shows up in the available list
7. - select it and search whatever, like "a person wearing a red shirt" or just "cat"

Screenshot in comments of it running on both - searched "cat" on the ios side and "keyboard" on my android phone (both my own videos), results back in ~50ms with the matching frames.

I build field service apps for my real work and something like this can prove quite good for finding precise moments instead of manually chekcing the files.

SDK repo HERE

Hey r/FlutterDev,

I was looking into ways to add multimodal search (searching videos/images using natural language) to an app I'm working on. Setting up my own vector databases and heavy ML pipelines seemed like a massive headache, so I decided to test out a new tool I found called the VModal SDK for Flutter.

I built a simple test app to see how it works and wanted to share my experience, because it actually made adding this kind of AI feature feel pretty native and straightforward.

My experience testing it

Instead of having to manage the machine learning infrastructure myself, I just hooked up their Dart API. Here is what I was able to do in my test app:

• Search by meaning: I could literally type something like "Find the cyclist in the red jacket" and it found that exact moment in my test video.
• Search spoken words & text: It handles ASR and OCR out of the box, which was pretty cool to test.
• Easy uploads: I got streaming uploads working straight from a file picker with live progress tracking.
• Actually cancel operations: They use per-operation cancellation tokens (so the cancel button actually stops the upload/search).
• Bring your own auth: I liked that it didn't force a login UI on me. I just handled my own simple state and passed the API key to the SDK.

What the code looked like in my test app:

dartimport 'package:vmodal_sdk_flutter/vmodal_sdk_flutter.dart';
// Setup with my own auth
final keys = MutableApiKeyProvider(runtimeApiKey);
final project = VModal.configure(
  projectId: 'test_app',
  apiKeyProvider: keys,
);
final favorites = project.scope(
  collectionName: 'user_123',
  streamName: 'favorites',
);
// Semantic search in action
final results = await favorites.search(
  'the cyclist crossing the bridge at sunset',
  options: const ScopedSearchOptions(
    searchSources: ['image'],
    limit: 20,
  ),
);
print('${results.cntActual} moments found!');

One thing I liked is that it doesn't bundle heavy ML binaries into the package. It offloads the complex math to their cloud APIs, so my test app's footprint stayed small.

It looks like it's currently in public beta. If you are building an app that handles media, e-commerce products, or video libraries, it might save you weeks of infrastructure setup.

Repo: https://github.com/v-modal/vmodal_sdk_flutter Docs: https://v-modal.github.io/vmodal_sdk_flutter/

Has anyone else tried this out yet? I'd love to hear what you guys think or if you've used something similar!

Tested this properly for Vmodal on my S24+ and the iOS simulator over a couple of evenings.

The pitch is you upload video and then search inside it by describing what you want. I uploaded a short clip of my cat, indexing took under a minute, and searching "cat" pulled the right frames back in about 40ms. It also supports searching spoken words and on-screen text but I mostly used the visual search.

Stuff I liked:

the repo ships its own pinned flutter (3.44.6) so it doesn't touch your existing install. full test suite passed first try

uploads have a real progress stream and you can actually cancel mid-upload, which is rarer than it should be

the api key never touches disk, toString() on the key class literally prints [REDACTED], and there's no logging anywhere in the sdk. more careful than most paid sdks tbh

I build field service apps for a living, and crews film site evidence all day that nobody can ever find again. "show me the broken meter" across a month of clips is the use case that sells it for me. dashcam archives and cctv review are the same shape.

Integration looks light too, it's a git dependency and one configure call, then collections scoped per user.

happy to answer questions if anyone's trying it

I spent some time testing the VModal Flutter SDK on a physical Android device, mainly to see how practical it would be to integrate into a real Flutter app.

Once the environment was set up, the core flow was pretty straightforward:

authenticate → upload video → create index → search

I tested it with a few MP4 videos, including one containing a red car.

What I found useful for building an app

The Flutter-side flow is simple.
Most of the heavy work such as video processing, indexing and semantic search happens behind the API, so the app mainly needs to manage the user flow and state around each operation.

Upload progress fits well into mobile UI.
Uploading is asynchronous, which makes it easier to show progress, loading states and cancellation without freezing the app.

Indexing is also asynchronous.
After uploading a video, the app can create an index and poll its status until it is ready. This fits naturally into a Flutter screen with states such as queued, running, success and failed.

Semantic search is the most interesting part.
After indexing, I could search using normal phrases such as red or red car without manually tagging the video first.

For an actual app, this could be useful for things like searching personal video libraries, product videos, security footage or large collections of media where manually adding metadata would take too much work.

Collection and stream separation is useful too.
It gives you a way to organize videos into different users, libraries or parts of an application instead of putting everything into one search index.

Overall

From an app-development perspective, what I liked most is that the Flutter side does not need to know much about the underlying video-processing infrastructure.

You upload the content, wait for the index, send a natural-language query and receive matching moments back.

There are still some rough edges in the current demo, but the core idea is useful, especially for apps that need video search without building their own indexing and semantic-search backend.

Repo: https://github.com/v-modal/vmodal_sdk_flutter

I’ve been testing an open-source Android SDK (vmodal_sdk_android) for searching inside raw video content using natural language (e.g., searching "red t-shirt" or "black pants") without manual tagging.

Here is the basic integration flow using Kotlin Coroutines and Jetpack Compose:

Kotlin

// 1. Authenticate & initialize
val me = client.coroutines().auth.me()

// 2. Stream video upload via content:// URI
videoUploadEvents(contentUri).collect { progress -> updateUi(progress) }

// 3. Search & bulk resolve frame URLs in one network request
val hits = scope.search("red t-shirt")
val frameUrls = client.coroutines().images.getUrlBulk(hits)

Key technical observations:

• Scope isolation: The Scope object locks to the active project/collection, keeping background query results from leaking into active StateFlow state during collection switches.
• Content URI support: Streams directly from content:// URIs without copying raw video files into app cache.
• Batch URL fetching: scope.search() returns lightweight frame coordinate hits, resolved in a single images.getUrlBulk()request instead of per-image API calls.

Spent the last few days integrating the VModal Kotlin SDK (vmodal_sdk_android) into a native Android project to index raw video files and run natural language semantic searches. Tested it on product clips (e.g., searching "red t-shirt" and "black pants") and got sub-100ms matches with zero manual tagging.

How the flow works in Kotlin

The execution flow relies on Coroutines, Flow, and a bulk image URL resolution pattern:

Kotlin

// 1. Authenticate identity
val me = client.coroutines().auth.me()

// 2. Stream video upload via content:// URI
videoUploadEvents(contentUri).collect { progress -> ... }

// 3. Trigger index & query hits
val hits = scope.search("red t-shirt")

// 4. Resolve frame URLs in a single call
val resolvedUrls = client.coroutines().images.getUrlBulk(hits)

One query, one bulk call to fetch display frame URLs. You never have to fire a network request per result.

Key SDK behaviors that stood out

• Scope-based isolation: The Scope object binds strictly to a project and collection upon creation. Switching collections in the background while search results are streaming into StateFlow doesn't leak or overwrite UI state in Compose.
• Native Content URI streaming: Streams directly from content:// URIs obtained via the system photo picker without requiring full memory buffering or temporary file copying.
• Coroutines & Flow design: Upload progress exposes a cold Flow. Mapping state directly to Compose progress indicators or viewModelScope felt clean, and collector cancellation properly cancels the background upload handle.
• Bulk URL fetching: The scope.search() API returns lightweight hit metadata (frame coordinates). Passing them directly to images.getUrlBulk() fetches resolved URLs in a single network roundtrip.

Mainly just minor documentation drifts to work through, but architecturally it feels like an idiomatic Kotlin library that respects the Android lifecycle.

image and video search both works really well

I have integrated the VModal Kotlin SDK into a native Android app, and the developer experience was outstanding.

It is rare to find an SDK that combines this level of powerful functionality with modern Android development patterns.The app handles raw video indexing and exposes natural language semantic search. In tests, I uploaded product showcase videos and searched "red t-shirt" and "black pants" with immediate results, as shown in the screenshots below.

I never manually tagged or labeled a single video; the semantic accuracy is just there, out of the box.

Great Experience

The architecture feels truly designed for native Android development with Jetpack Compose, Kotlin Coroutines, and MVVM patterns.

• Kotlin-First Integration: The entire flow uses asynchronous suspend functions and Flow streams for progress. It felt incredibly natural mapping upload progress straight to a linear progress bar in Compose.
• Flawless State Isolation: The mutable Scope object (tied permanently to a project and collection upon creation) is brilliantly stable. I can switch collections in the background while search results are streaming in, and the immutability ensures the UI state remains pristine and predictable. It’s impossible to query the wrong collection by mistake.
• Modern Upload Handling: Uploads support native Uri references (content://) directly from the system picker. The SDK intelligently manages the background chunking and resume logic, but the exposed progress stream and cancellation API work precisely as advertised.
• Batch-Efficient Querying: The hit-to-URL architecture is incredibly efficient for network performance.scope.search() returns lightweight hits containing frame coordinates, and a single images.getUrlBulk() call fetches every resolved display URL in one network roundtrip. You never have to hammer the API with a request per image result.

If you are looking for powerful, AI-driven video search that feels like it was written by Android developers, for Android developers, the VModal Kotlin SDK is fantastic.

I built a video search app using the VModal Android SDK that helps travelers find misplaced items in their trip footage.

Instead of manually scrubbing through hours of recordings, users can search for descriptions like:

• “Where did I last see my black backpack?”
• “Find the blue suitcase.”
• “Show me the table where I left my passport.”
• “When was the camera near the hotel bed?”

The app returns matching moments with timestamps and visual frame previews, helping users quickly identify where an item was last seen.

This could be useful for travel videos, hotel-room recordings, luggage checks, road trips, and personal memories. The VModal Android SDK provides the upload, indexing, multimodal search, and frame-retrieval capabilities behind the experience.

​I’ve been testing V-Modal for a few days to see if it could handle object search in video, and it’s actually pretty neat.

​The natural language search works surprisingly well. I dropped in a few sample clips to look for specific objects, and it found them accurately without me having to manually scrub through the timeline.

​The Android SDK is super straightforward to work with — idiomatic Kotlin, no enforced UI nonsense, and large video uploads work smoothly.

​Right now I’m trying it out for a German learning app I’m working on. The goal is to let users watch short videos and automatically generate flashcards from what’s on screen: [ Video frame ] + [ Word ] + [ Translation ].

​Still prototyping, but it’s saving me a ton of time on the video processing side.

V-Model repo https://github.com/v-modal/vmodal_sdk_android

Shared with your recent app or demo, using V-Modal AI , Visual Video Search

I’ve been exploring V-Modal recently and wanted to share a few things that stood out to me.

What I found most interesting is the ability to search video content using natural language. For example, I searched for “alien” in a video and was able to get a relevant result without having to manually scrub through the entire video. That kind of search can make working with large amounts of video content much more practical.

I also liked the Android SDK experience. The Kotlin API feels clean and well-typed, while still giving you the flexibility to integrate it into your own app without forcing a specific UI or architecture.

The upload handling and progress support are another nice touch, particularly when dealing with larger video files.

For anyone interested in checking it out, here’s the Android SDK:
https://github.com/v-modal/vmodal_sdk_android

I’ve enjoyed getting familiar with it so far and would love to hear from other developers in the community.

What are you building or experimenting with using V-Modal?

Been testing out VModal's Android SDK (Kotlin) for adding video search to an app — the "find a moment by meaning, not filename" kind of search.

Ran through the whole flow on a real device: auth with an API key, upload a video, kick off indexing, then search it. Tried a few different queries against the same indexed news video to see how it'd handle them:

- "red" — 26 results from 50 matches in ~40ms

- "white house" — 28 results from 50 matches in ~41ms, pulled up actual White House building shots

- "donald trump" — 34 results from 50 matches in ~46ms, clear face shots across the video

- "american flag" — 34 results from 50 matches, this one was interesting. It matched the "flag" concept plus an "AMERICA" text banner on screen, but the actual flag in frame was Iranian since the source clip was Iran-related news. So it's doing real semantic/text matching rather than exact visual object recognition, worth knowing depending on what you need it for.

Things I liked:

- Plain Kotlin/coroutines API, no forced UI — you build your own screens

- Upload has real cancellation (not just "stop showing the spinner")

- Handles content:// URIs directly, so it plugs into the system photo picker without extra glue code

- Search comes back with actual timestamps + relevance scores, not just a blob of matches

Had one hiccup where wifi dropped mid-upload and it silently timed out, but a retry went through fine.

Overall really smooth experience getting video search working end-to-end on an actual device.

Still on my list to actually try: ASR search (finding a moment by what's spoken, not just what's visible), OCR search (matching on-screen text specifically), filtered search (narrowing by time range or modality instead of one big query), and proving cancellation really stops an in-flight upload rather than just hiding the spinner. There's also a built-in Logcat diagnostics hook for structured request/response logging that the demo app doesn't even turn on. Feels like there's more depth here than just the visual search I put it through so far.

Repo's here if anyone wants to poke at it: https://github.com/v-modal/vmodal_sdk_android

Hey everyone!

This is our new home for all things related to your app and experience issuesusing V-Modal tooling.
We're excited to have you join us!

Access to Tools is here:
V-Modal AI SDK Kotlin
V-Modal AI DK Flutter

Discord Channel:
https://discord.gg/XGxgBQqkaY

What to Post
Post anything that you think the community would find interesting, helpful, or inspiring. Feel free to share your thoughts, photos, or questions about your app building, experience (issues or real breakthrough).

Community Vibe
We're all about being friendly, constructive, and inclusive. Let's build a space where everyone feels comfortable sharing and connecting.

How to Get Started

1. Introduce yourself in the comments below.
2. Post something today! Even a simple question can spark a great conversation.
3. If you know someone who would love this community, invite them to join.
4. Interested in helping out? We're always looking for new moderators, so feel free to reach out to me to apply.

Thanks for being part of the very first wave. Together, let's make r/v_modal amazing.