Marco Polo has no desktop app, no web app, and no API. This is the complete guide to running the real Android app on a Windows PC — watch and record polos with a real camera (or your whole OBS scene) — and then bolting on a memory engine: automated harvesting, local Whisper transcription, and Claude-powered analysis that turns months of video messages into a searchable, queryable archive.
Half one puts the app on your monitor with a proper camera — the Polo Station. Half two is the part nobody else has: a pipeline that pulls every video message out of the app, transcribes it locally, has Claude analyze each one, and compiles the whole conversation into a single document you can ask questions of. Build the first half in an afternoon; the second half is where it becomes a superpower.
The genuine Android app inside a BlueStacks 5 emulator, signed into your account, recording through your PC camera — or through OBS, so polos capture your entire streaming scene.
Scripts that walk the conversation history, download every polo, transcribe with Whisper on your GPU, analyze each one with a Claude agent, and compile it all into one queryable log.
You don't need to be a developer — this whole build was made by describing each problem to Claude and letting it drive. You do need:
adb) — winget install Google.PlatformTools.Install BlueStacks 5 and create an Android 11 instance (internally named something like Rvc64). Give it 4 CPU cores and 4 GB RAM. Inside it, open the Play Store, install Marco Polo, and sign in with your account. Your conversations sync in from the cloud.
Everything scripts do starts with these two:
"C:\Program Files\BlueStacks_nxt\HD-Player.exe" --instance Rvc64 adb connect 127.0.0.1:5555
From here on, adb shell can tap, swipe, dump the UI, pull files, and read logs — the whole automation half rides on it.
Out of the box, recording fails: black videos, "Yikes, message didn't record", or the app crashing the moment you open a chat. The fix is a hidden config setting BlueStacks never shows you.
Close BlueStacks, then edit C:\ProgramData\BlueStacks_nxt\bluestacks.conf and set these keys for your instance:
bst.instance.Rvc64.camera_backend="ffmpeg" # THE fix — default "qt" can't hold the camera bst.instance.Rvc64.camera_rotation_angle="90" # upright, properly-proportioned portrait video bst.instance.Rvc64.graphics_renderer="vlcn" # Vulkan — "gl" broke recording, "dx" stalled bst.instance.Rvc64.enable_adb_access="1" # lets scripts drive the instance
Relaunch, and recording just works. This single line — camera_backend="ffmpeg" — was the breakthrough of the whole build.
Every time the BlueStacks Settings UI saves, it reverts those hidden keys. Backend goes back to qt (black recordings, crashes) and rotation back to 0 (squeezed, long-thin-face video). Write yourself a small "repair" script that stops BlueStacks, rewrites the keys, and relaunches — then fixing it is one command instead of a debugging session.
Point the BlueStacks camera at OBS Virtual Camera instead of the webcam and your polos record whatever OBS outputs — overlays, gameplay, multi-cam scenes. One catch: Marco Polo mirrors its camera like a selfie cam, so text comes out backwards. Fix it in OBS with a wrapper scene (call it POLO FLIP) containing your real scene with Transform → Flip Horizontal. Two mirrors cancel; text reads correctly. Your actual stream is untouched.
Marco Polo's own self-view stays black while recording on emulators — its GL filter pipeline doesn't survive the emulator's graphics translation. Recording is unaffected; you just can't see yourself in-app. The workaround: keep the Windows Camera app open beside BlueStacks as a live mirror (Windows 11 lets two apps share one camera), or in OBS mode the OBS window itself is your preview.
Polos live in Marco Polo's cloud and stream in on playback — the local cache is unreachable without root. The extraction route is the app's own Save feature (a Plus perk): it writes a clean MP4 to Android's Movies/ folder, named by the polo's recording timestamp. Automate that tap and you can drain an entire conversation's history.
A PowerShell harvester drives the app over ADB. For each thumbnail in the conversation's bottom strip: long-press it → read the popup title (sender + date) from a UI dump → if it's not already in a local index CSV, tap "Download to device" → log it. Then swipe the strip one page older and repeat.
polo_index.csv of everything captured; it's what makes incremental runs possible.adb pull — and keep personal video out of cloud-synced folders.After the first full-history harvest, daily updates are cheap: reset to newest, walk newest → oldest, download anything new, and stop at the first polo you've already captured. Most days that's a 30-second run that finds one or two new polos — perfect to wrap in an agent skill so "update the polos" is the entire workflow.
Skip the app's built-in transcript (it's rough) and cloud APIs (they cost money and upload private video). faster-whisper with the small.en model runs locally — about 25× realtime on an RTX 2070, so an 11-minute polo transcribes in ~30 seconds. CPU fallback still works, just slower.
pip install faster-whisper nvidia-cublas-cu12 nvidia-cudnn-cu12
A small watcher script keeps it hands-off: every run, it pulls any new device MP4s, transcribes anything without a .txt, and writes timestamped lines beside each video.
Each transcript gets analyzed by its own agent (run them in parallel — a batch of polos analyzes in minutes). Each agent writes one JSON file with a fixed shape:
{
"sender": "who recorded it",
"gist": "one line, ≤12 words",
"summary": "2-3 sentences",
"topics": ["personal" | "podcast"],
"tasks": ["things someone said they'd do"],
"insights": ["key takeaways"],
"brainstorms": [{ "about": "...", "ideas": ["..."] }]
}
A compile script merges every analysis JSON + transcript, chronologically, into a single outline-formatted file: per polo — sender, date, gist, summary, tags, tasks, insights, brainstorms, full transcript nested underneath — with rollups at the top (every task, every brainstorm, the whole podcast thread). One conversation, one file, always current. Re-run it after every harvest.
A months-long conversation compiles to a file too big to feed an AI whole (~240K tokens with transcripts). The trick: the analysis layer alone is ~5× smaller, and most questions only need a slice of it. So the last piece is a tiny query script that prints exactly the slice you need.
| You want | Slice |
|---|---|
| Podcast / project ideas | every brainstorm tagged with your project tag |
| "What did I say I'd do?" | all tasks, chronological, by sender |
| Key takeaways | all insights |
| A quick refresher | gist + summary per polo |
| Open loops, recurring themes | the whole analysis layer (no transcripts) — let the AI reason over it |
| Exact words of one moment | a single polo's full transcript |
| Symptom | Cause → Fix |
|---|---|
| "Yikes, message didn't record" / black video | Settings save reverted camera_backend to qt → rewrite the conf keys, relaunch |
| Face squeezed / long and thin | Rotation reverted to 0 → set camera_rotation_angle="90" again |
| App icon opens and instantly closes | A Play Store auto-update mid-batch corrupted the app's compiled code → force a clean recompile via ADB (pm compile -m speed -f the package); non-destructive, ~20s |
| Polos record the OBS standby logo | OBS mode with Virtual Camera not started → Start Virtual Camera, point it at your flip scene |
| Text mirrored in scene recordings | Virtual Camera aimed at the raw scene → aim at the flipped wrapper scene |
| Self-view black while recording | Emulator limitation — permanent → use Windows Camera or the OBS window as your mirror |
| Harvester "spins" and never pages older | A tap strayed onto the hidden jump-to-newest button → keep all taps/swipes left of it |
| Long-press plays the video instead of opening the menu | The cell was still animating → wait for a clean, settled strip before touching it |
adb logcat -d > crash.log before you repair anything — the recompile overwrites the crash evidence.