Model or dataset
QmiAI/Qmedia avatar
QmiAI/Qmedia

qmedia: three services, three spellings of the same name

An open-source AI content search engine designed specifically for content creators. Supports extraction of text, images, and short videos. Allows full local deployment (web app, RAG server, LLM server). Supports multi-modal RAG content Q&A.

641 stars75 forksTypeScriptMIT

At a glance

What is it?
QMedia is a MIT-licensed open-source content search engine for creators that splits into a multimodal model service, a retrieval service and a web interface, each deployable on its own hardware. The parts that work are the retrieval breakdown and the local transcription path; the parts marked with unticked boxes are the visual understanding and video analysis features.
Who is it for?
QMedia is worth reading if you are building creator-facing search over images and short video, because its central idea, that retrieval should run over a decomposition of the content rather than the file itself, is the right shape for that problem, and the model service is separable enough to test on a laptop before committing hardware. Three cautions.
Can I use it commercially?
Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Activity is slowing. The repository last received commits 7 months ago.
What is it written in?
Mainly TypeScript, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • QmiAI/Qmedia641 ★ · +5
Star history
Repository2026-09-112026-11-15
QmiAI/Qmedia636641

5 Stars in the last 65 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

Three services that can be split across machines

The architecture is three deployable services rather than one application, and the split is what makes the project adaptable to what a user has available. The model service handles multimodal model deployment and API calls: the language models, the image models, the video models and the feature embedding models. The retrieval service does content card display and query, plus the extraction, embedding and storage of image, text and short video content, the multimodal retrieval itself, and content question answering. The web service is the interface. The readme is explicit that they can be deployed separately depending on the resources available, that model services can be deployed in the cloud instead, and that the whole set can be embedded into other systems for extraction. That last point matters more than it sounds: the model and retrieval layers are described as separate from the application layer specifically so a different model can be swapped in without touching the RAG code. Each service has its own directory with its own Dockerfile and its own installation notes in the repository.

The compose file spells the retrieval service three ways

The shipped compose file is short enough to read in full, and it contains a naming inconsistency that will cost you an afternoon if you extend it. The web service points at the retrieval service by container name, and that name contains a typo:

code
  qmedia-web:
    build:
      dockerfile: ./qmedia_web/Dockerfile
    restart: always
    container_name: qmedia_web #容器名稱
    environment:
      - SERVICE_ENDPOINT=http://qmedia_mmarg_server:50111
    depends_on:
      - qmedia-mmrag  
    ports:
      - 50112:50112

The service key is `qmedia-mmrag` while its container name is `qmedia_mmarg_server`, and the model service is keyed `qmedia-mmsever` with the container name `qmedia_mm_server`, so three spellings of two services are in play across thirteen lines. Docker resolves it, because the endpoint uses a container name and the dependency list uses service keys. Two other things are worth noticing. There are no health checks, and the dependency declarations carry no readiness condition, so the web interface can start before the retrieval service is listening and fail its first requests. And the asset directory is mounted into the retrieval service only, so anything the model service writes outside its own container filesystem does not survive a restart. The three published ports are consecutive, 50110 for models, 50111 for retrieval and 50112 for the interface, which is at least a navigable layout.

Retrieval runs over a breakdown, not over the raw file

The idea that distinguishes this from a plain vector search over documents is in the retrieval description. Searching image, text and short video materials is the visible feature, but what retrieval and question answering actually rely on is the decomposition of that content: image style, text layout, short video transcription and video summaries. That means the index is built from extracted attributes rather than from an embedded original, and it explains why the answer can cite sources. Presentation follows the same logic. Content cards are the display unit for image, text and video material, and the sources plus the breakdown are surfaced through those cards rather than as a separate citations panel. Answers are generated from whatever the query retrieved, and results are customised to user interests and needs. So the quality ceiling of the whole system is set by the extraction step, not by the language model, which is a useful thing to know before you start swapping models around.

The web interface is modelled on a specific product

The front end is described as a web service inspired by the web version of a specific Chinese social platform, and the stack is named in full: TypeScript, Next.js, Tailwind CSS and a component library. That is an unusually direct statement of the design target, and it tells you more about the intended result than a screenshot would. The back end of the same system is a different language entirely. The retrieval and question answering service and the image, text and video model service are implemented with a Python framework and LlamaIndex applications, so the project is a TypeScript front end over a Python retrieval stack rather than one codebase. Feature-wise the interface carries the card grid, search and the question answering surface, while the extraction and embedding work stays server-side. Nothing in the collected documentation describes the interface's own language, setup or configuration: the section for that service is cut off partway through its first line, so this review cannot say what framework it uses or how it is configured.

One named implementation per modality

The local model story is small and specific rather than a menu. Language models come from Ollama with local switching between them, and two sizes are named: an 8 billion parameter instruct model described as a lightweight local deployment, and a 70 billion parameter instruct model. Feature embeddings are split by modality with exactly one implementation named for each. Images go through a CLIP encoder, which maps an image into a text-like feature space. Text goes through a BGE encoder, chosen as a multilingual embedding model whose local weights are aligned to the GPT encoder. Image understanding is narrower still: OCR on image text through a QAnything-based recogniser, with a line for image layout and character recognition through a segmentation model left commented out in the documentation rather than described. That pairing of one encoder per modality is worth noting for a multimodal index, because it means image and text vectors are not directly comparable and cross-modal retrieval has to happen after decomposition rather than in a single shared space.

Untick checkboxes are the status markers

The feature list uses checkboxes, and reading them is the fastest way to see what actually exists. The visual understanding entry for a Llava-based model on Ollama carries an unticked box. In the video group, transcription through a faster Whisper implementation is listed without a box and is described as running on a local CPU, while the entries for identifying highlights in short videos, recognising short video style types, and analysing and breaking down short video content all carry unticked boxes. So transcription and the language-model summarisation line read as present, while visual understanding and the video analysis trio read as unbuilt. Four future plans sit in their own unticked list: analysis and viral breakdown of image and text short video content, search for similar image, text or video, card image and text content generation, and short video content editing. The document does not separate done from planned cleanly in every case, which is why the boxes are worth more than the prose in a project without releases.

Local model lifecycle management is configurable, not automatic

One operational detail is easy to miss and useful to anyone running this on a shared machine. Local model lifecycle management is called out as a feature, configurable for manual or automatic release in order to reduce server load. In practice that means the model service decides when a model leaves memory, and the trade-off is between holding a model resident for latency and holding it for memory pressure. With Ollama in the middle, that also means the large model is the one worth thinking about: an 8 billion parameter model and a 70 billion parameter model are very different residents, and a machine that runs the first comfortably may not run the second at all. The transcription path is the friendliest part of the whole stack for a modest machine, because it is explicitly described as running on a local CPU. Everything else in the retrieval path wants an accelerator, and the readme does not give hardware numbers, so any sizing decision has to be made by measurement rather than from the documentation.

Google content search is listed as a supported capability

One capability sits apart from the rest of the retrieval story. Support for Google content search is listed among the multimodal RAG features, which means the system can reach beyond the indexed local corpus. For a creator tool that is the difference between searching what you have and searching what exists, and it is the kind of feature that quietly changes the privacy story of a deployment described as local-first, since offline search over private data and live web results are different promises made by the same product. The documentation does not say how the Google integration is configured or authenticated, so treat it as a documented capability rather than a documented mechanism. Two more facts frame any evaluation. The last push was on 2026-04-09, and the repository has no GitHub releases at all, so there is no tag to pin and nothing to compare a deployment against. The repository does carry a changelog and both English and Chinese readmes, plus a top-level test directory.

Editorial conclusion

QMedia is worth reading if you are building creator-facing search over images and short video, because its central idea, that retrieval should run over a decomposition of the content rather than the file itself, is the right shape for that problem, and the model service is separable enough to test on a laptop before committing hardware. Three cautions. The readme marks unfinished work with unticked checkboxes, and the visual understanding and video analysis items are among them, so scope your evaluation to transcription, embedding and card presentation. The shipped compose file spells the retrieval service three different ways and has no health checks, so expect ordering problems on a cold start. And the last push was on 2026-04-09 with no GitHub releases; pin a Git commit for a reproducible source snapshot and inspect the commit history for changes.

Frequently asked questions

What are the three services in the qmedia project?

A multimodal model service for language, image, video and embedding models, a retrieval service that does content cards, extraction, embedding, storage, multimodal retrieval and question answering, and a web service as the interface. All three can be deployed separately.

What does qmedia retrieve over, files or extracted attributes?

Extracted attributes. Retrieval and question answering rely on the decomposition of content, including image style, text layout, short video transcription and video summaries, and results are surfaced through content cards that also show the sources.

Which embedding models does qmedia use for images and for text?

Images go through a CLIP encoder and text through a BGE encoder, described as a multilingual embedding model whose local weights are aligned to the GPT encoder. Language models are served through Ollama with local switching.

Which qmedia video features are finished?

Video transcription through a faster Whisper implementation is described as running on a local CPU. Identification of highlights, recognition of short video style types, and analysis and breakdown of short video content all carry unticked checkboxes in the feature list.

How does the qmedia compose file wire the three services together?

The web service reaches the retrieval service by container name over port 50111 and is published on 50112, the model service is published on 50110, and the retrieval service mounts the asset directory. The file contains no health checks and no readiness conditions on the dependencies.

Does qmedia need to run in the cloud?

No. The three services can be deployed locally depending on the resources available, and the readme says model services can be deployed in the cloud instead. Local deployment is what enables offline search and question answering over private data.

Official sources

  1. Issues
  2. License: MIT
  3. QmiAI/Qmedia on GitHub
  4. README
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/qmiai-qmedia.svg)](https://hysenlabs.com/projects/qmiai-qmedia)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/qmiai-qmedia.svg)](https://hysenlabs.com/projects/qmiai-qmedia)

Was this useful?