Hi everyone — I’m the sole developer of Meet2Notes, an MIT-licensed open-source meeting assistant currently in alpha.

The goal is simple: provide a local-first meeting workspace for recording, transcription, speaker separation, AI notes, historical search and live AI assistance, without requiring a subscription or sending all meeting data to a third-party SaaS.

What Meet2Notes can do

Meet2Notes currently supports:

• Recording microphone and system/desktop audio
• Importing existing audio or video files
• Live transcription during the meeting
• A separate higher-quality final transcription pass
• Speaker diarization
• Saved voice profiles and speaker recognition across meetings
• Structured AI meeting notes
• Local historical RAG across one meeting or the complete meeting library
• Asking questions about meetings with timestamped source excerpts
• An optional Live AI Assistant
• Local API access
• Live and post-processing webhooks
• External AI agent suggestions during meetings

Meet2Notes records the audio available on your computer, so there is no bot that needs to join Zoom, Teams, Google Meet, etc.

Fully local setup

A completely local setup is possible.

Recordings, transcripts, speaker data, AI notes, embeddings and RAG data can all remain on your machine.

Meet2Notes stores meeting data in a local SQLite workspace and supports local AI models for the different processing stages.

Remote AI providers are optional.

If you configure Ollama, LM Studio, LiteLLM or another OpenAI-compatible endpoint, Meet2Notes can use that instead.

API credentials are stored through the operating system keyring rather than in the application database or browser storage.

Selectable transcription engines

One of the main design decisions was not tying the application to a single transcription model.

Live transcription and final transcription are configured independently.

For example, you could use a lightweight model during the meeting and then run a slower but more accurate model afterwards.

Current transcription options include:

• Faster-Whisper
• NVIDIA Parakeet TDT 0.6B v3
• NVIDIA Nemotron 3.5 ASR Streaming 0.6B
• Microsoft VibeVoice ASR BitNet as an experimental CPU-oriented option

With Faster-Whisper, several model sizes are available, including Tiny, Base, Small, Medium, Large-v3, Distil-Large-v3 and Large-v3-Turbo.

Speaker diarization and recognition

Transcription and diarization are separate stages.

Current diarization options include:

• Sherpa-ONNX
• Pyannote Community-1
• diarize

After diarization, speakers can be renamed and voice samples can be stored locally.

The idea is that Meet2Notes can eventually recognize that Speaker 2 is actually the same person you already identified in previous meetings.

There is also a dedicated Speakers workspace where you can inspect a speaker's meetings, generate speaker-specific summaries and export their associated text or audio.

AI meeting notes

Meet2Notes can turn the transcript into structured Markdown notes.

There are built-in note formats for different types of meetings, including:

• General Meeting
• Daily Stand-up
• Project Sync
• Sales Call
• Technical Meeting
• Interview
• Lecture Notes
• Brainstorming
• Formal Minutes

Custom formats can also be created.

AI analysis is independent from transcription, so you can choose a separate local model for notes.

Local GGUF models can run through llama.cpp, and external/local-compatible providers can be connected through LiteLLM.

Search your meeting history with RAG

Meet2Notes can build a local searchable index of previous meetings.

You can ask questions about:

• one specific meeting
• the complete meeting library

For example:

• “What did we decide about the API migration?”
• “When did we first discuss Project X?”
• “What action items came up in the last three meetings?”
• “What did Alice say about the pricing issue?”

Retrieved context includes meeting and timestamp information so you can trace the answer back to the original transcript.

The RAG layer can also remain completely local.

Live AI Assistant

Meet2Notes includes an optional Live AI Assistant.

Instead of waiting until the meeting finishes, the assistant can monitor incoming transcript segments and show short insights while the conversation is still happening.

You can define what it should watch for.

For example:

• unanswered questions
• decisions
• action items
• contradictions
• important numbers
• risks
• topics you wanted to discuss
• things that need clarification

The assistant has its own model configuration and worker.

Recording and transcription do not wait for the LLM, so a slow AI response does not block the meeting pipeline.

Live AI agents through webhooks

This is one of the parts I’m most interested in experimenting with.

Meet2Notes can send committed live transcript segments to external systems through webhooks.

That means you could connect it to an internal AI agent with access to your own:

• RAG
• company documentation
• CRM
• project management system
• databases
• internal APIs

For example, someone could ask during a meeting:

>“What did we decide about this feature three months ago?”

An external agent could receive the conversation, query the company knowledge base and send a suggestion back while the meeting is still happening.

The same idea could be used during sales calls, technical meetings, support calls or internal planning sessions.

Webhook processing is isolated from recording and transcription, so network failures or slow external agents do not block the local capture pipeline.

Webhooks include:

• HMAC signatures
• retries
• delivery history
• per-endpoint content controls
• live transcript events
• processing milestones
• optional remote-agent suggestions

Modular architecture

Transcription, diarization, saved-speaker recognition, embeddings, AI notes and the Live AI Assistant are independent components.

Each can have its own:

• engine
• model
• settings
• worker
• lifecycle

This makes it possible to run a lightweight configuration on a laptop or use larger models when better hardware is available.

It also makes adding new transcription, diarization or AI engines easier without rewriting the entire meeting pipeline.

Privacy

Meet2Notes is designed to work without requiring a cloud account.

With a fully local configuration:

• recordings stay local
• transcripts stay local
• speaker voice profiles stay local
• AI notes stay local
• embeddings stay local
• RAG stays local

Nothing needs to leave the computer.

Remote providers are available only if the user explicitly configures them.

Current status

Meet2Notes is still alpha software and under active development.

I’m the sole developer, so I would not yet recommend using it as the only copy of an irreplaceable recording.

Please also make sure you have the appropriate consent before recording conversations.

The project is MIT licensed and contributions, issues and technical feedback are welcome.

GitHub:
https://github.com/estebanstifli/Meet2Notes

I’d be especially interested in feedback from people already using AI meeting tools:

1. Which feature matters most to you: transcription quality, speaker attribution, notes, RAG/search, integrations or live assistance?
2. Would you use separate models for live and final transcription?
3. Is persistent speaker recognition across meetings useful to you?
4. Would you connect a live meeting transcript to your own local/internal AI agent?
5. What would Meet2Notes need before you would trust it for your real meetings?

Hi r/mcp,

About a year ago, I built my first MCP server for WordPress. It was a huge learning experience: protocol changes, OAuth, tool design, security, and the reality of letting an AI interact with a CMS safely.

Since then, I kept running into the same issue: managing several WordPress MCP servers from different AI clients quickly becomes messy.

So I built my first MCP Hub: WP MCP Hub
https://github.com/estebanstifli/wp-mcp-hub

It is a free, open-source, local Python application that gives an AI client one stable MCP connection while routing requests to multiple remote WordPress MCP servers.

It can work with standards-compatible WordPress MCP servers that expose Streamable HTTP or SSE, including:

• Easy MCP AI
• Royal MCP
• StifLi Flex MCP — also my project, so I want to be fully transparent about that

The Hub does not replace those plugins or their WordPress permissions. Each remote site keeps its own tools, authentication, and capability checks; the Hub focuses on local configuration, site selection, diagnostics, credentials, and routing.

Current features include:

• One local stdio MCP server for multiple WordPress sites
• Remote MCP connections via Streamable HTTP and optional SSE
• OAuth 2.1, Bearer token, custom-header/API-key, or no-auth connections
• Credentials stored in the operating system keychain rather than SQLite or normal logs
• A local dashboard for adding sites, testing connections, pinging, reconnecting, browsing tools, and reviewing activity
• Support for Claude Desktop, Codex, ChatGPT Desktop local coding, Gemini CLI, and other stdio-capable MCP clients
• No hosted relay, subscription, telemetry, or need to expose the local dashboard to the internet

It is still an alpha project. This is my first MCP Hub, and I would genuinely appreciate feedback from people with more MCP experience than me.

I would especially love thoughts on:

• Is the hub approach useful, or does it add too much abstraction?
• Are there security or trust-boundary problems I should address?
• What would make this more useful for agencies or developers managing multiple WordPress sites?
• Should authenticated remote HTTP ingress be a priority in a future version?
• Is the site-selection and local tool-routing workflow sensible?

Constructive criticism, protocol feedback, feature ideas, and brutal honesty are very welcome.

Thanks for taking a look.

Hi everyone,

I’m Esteban, the developer of LocalText2Voice, a free and open-source Windows application for creating audiobooks, narration, and podcasts with local TTS engines.

There are already many excellent local TTS models, but turning them into a practical long-form workflow still involves a lot of manual work: installing dependencies, splitting text, managing voices, regenerating failed sections, organizing audio files, and mixing everything afterward.

LocalText2Voice is not another TTS model. It is an orchestration and production layer around existing engines.

It currently supports local engines such as Piper, Kokoro, Chatterbox, Qwen3-TTS, and OmniVoice. Optional cloud providers such as OpenAI, ElevenLabs, Gemini, and Azure are also available, along with configurable HTTP endpoints for custom TTS servers.

When using a local engine, the source text and generated speech remain on your computer.

Current features

With LocalText2Voice, you can:

• Install and manage different TTS engines from the application.
• Switch between engines without changing your project.
• Browse, preview, import, and organize voices in a shared voice library.
• Connect custom local or remote TTS HTTP endpoints.
• Import long .txt, .md, and .docx documents.
• Detect chapters and split long texts into safe TTS segments.
• Use different voices and languages in the same audiobook.
• Regenerate individual segments without starting the entire project again.
• Review generated speech with Faster Whisper and retry problematic segments.
• Add background music, fades, ducking, volume adjustments, and normalization.
• Sound effects and other audio events.
• Save projects and continue working on them later.

LTV Markup

One feature for which I would particularly appreciate feedback is LTV Markup.

It is a small, human-readable syntax for controlling narration, voices, pauses, and sound effects directly from the source text:

{{chapter "Chapter 1"}}
{{voice "Narrator"}}
The house had been abandoned for years.

{{pause 900ms}}

{{voice "Character 2"}}
I think someone is inside.

{{play "door-close.mp3"}}

{{speed 0.92}}
{{volume -3db}}
We should leave immediately.

Markup can control:

• Voice and language changes.
• Pauses and real silence.
• Speech speed.
• Volume and normalization.
• Chapters and markers.
• Sound effects and other audio events using {{play}}.
• Audio volume, duration, looping, fades, panning, and voice ducking.
• Selected model-specific instructions.
• Resetting settings to the project defaults.

For example:

{{play "door-close.mp3" volume=-6db}}

inserts a door sound at that point in the narration.

Longer or looping audio events are also possible:

{{play "forest.mp3" track=ambient loop=true volume=-20db fade_in=3 duck_on_voice=6db}}

The commands are not sent to the TTS engine as spoken text. LocalText2Voice interprets them when preparing the segments and mixes the audio events during post-production.

The goal is to make multi-character audiobooks, dramatized narration, language courses, and other complex audio projects manageable without manually editing every segment in an external audio editor.

Create audiobooks from Claude or ChatGPT Desktop

LocalText2Voice includes a local MCP server, allowing you to create and manage audiobook projects directly from Claude Desktop or ChatGPT Desktop.

Instead of configuring everything manually, you can simply ask:

>“Create a B1-level English–Spanish course using both languages. Use one voice for the English examples, another for the Spanish translations, add a short pause after each sentence, and export it as an audiobook.”

The assistant can create the project, organize the text, assign the voices, add markup and pauses, select a TTS engine, and start the generation process.

You can also ask it to make changes later:

>“Regenerate lesson three with a slower English voice.”

>“Add three seconds of silence between exercises.”

>“Lower the background music and export the final MP3.”

Claude or ChatGPT manages the workflow, while LocalText2Voice performs the actual audio generation. When you select a local TTS engine, your text and generated speech remain on your computer.

Project and Windows installer

GitHub:

https://github.com/estebanstifli/LocalText2Voice

LTV Markup manual:

https://github.com/estebanstifli/LocalText2Voice/blob/main/docs/LTV_MARKUP.md

Windows installer:

https://github.com/estebanstifli/LocalText2Voice/releases/latest/download/LocalText2Voice-Setup.exe

Important: the Windows installer is not code-signed yet, so Windows may display an “Unknown publisher” or SmartScreen warning. The source code is public, and the GitHub release also includes a SHA-256 checksum:

https://github.com/estebanstifli/LocalText2Voice/releases/latest/download/LocalText2Voice-Setup.exe.sha256

The project is under active development, and feedback is very welcome. I would especially like to know:

1. Which local TTS engines are you currently using?
2. What is the most frustrating part of producing long-form audio?
3. Does the markup syntax seem useful, and which commands are missing?
4. Which engine should I prioritize next?

Thanks for taking a look!

Hi everyone,

I recently released a WordPress plugin called StifLi Backup Tools.

It is a 100% GPL backup, restore, migration and staging plugin for WordPress. My goal with this project is simple: offer many of the backup/migration features that are often locked behind paid plans in other plugins, but keep the core toolkit free and open.

The plugin includes:

Full site backups

Database-only backups

Scheduled backups

Differential scheduled backups

Restore and selective restore

Backup integrity checks

Migration packages

Push/Pull site-to-site migration

Staging sites

Remote storage: Google Drive, Dropbox, Amazon S3, Cloudflare R2 / S3-compatible storage, FTP and SFTP

Database cleanup, image optimization and maintenance tools

No telemetry, no license checks, no cloud dependency for the core plugin

I built it mainly for real WordPress sites, including shared hosting environments where long backup/restore processes often fail. It uses background processing, resumable jobs, chunked ZIP creation and streaming database operations to try to avoid common timeout/memory problems.

I know the backup plugin space is very competitive, so I am not claiming this is “better than everything else”. What I would really like now is real-world feedback.

I am especially interested in:

Sites where other backup/migration plugins failed

Large or awkward WordPress migrations

Shared hosting environments with strict limits

Remote storage workflows

Restore/migration edge cases

I am also willing to help with a limited number of migration cases for free, mainly to learn from real environments and improve the plugin. Of course, I would only do this in a safe way: staging/test sites where possible, temporary access only if needed, and never asking anyone to post private credentials publicly.

For trust/context: I am not completely new to WordPress development. I currently have 6 plugins published on WordPress.org with 4,000+ active installations across them. This backup plugin is part of that same ecosystem.

Plugin page / documentation:

https://wordpress.org/plugins/stifli-backup-tools/

WordPress.org profile/plugins can also be found from:

https://andromedanova.com

I would really appreciate feedback, criticism, feature requests, or difficult migration cases where this kind of tool could be useful.

Thanks!

Stifli Flex MCP is 100% free and GPL-licensed (no paid tier, no upsell, no premium lock):
https://wordpress.org/plugins/stifli-flex-mcp

Connector directory:
https://wordpress.org/plugins/tags/connector+ai/

I also built a Groq connector:
https://github.com/estebanstifli/ai-connector-for-groq

Current AI Copilot test status:

• OpenRouter: working well
• Mistral: working well
• Native providers (OpenAI, Claude, Gemini): working well
• Groq: partially tested only

I haven’t been able to fully validate Groq in AI Copilot because of free-tier API limits (and Developer Tier upgrades being temporarily unavailable).

If anyone has Groq Developer Tier and can test AI Copilot flows (rewrite, improve content, tool/function calling), I’d really appreciate feedback:

• Which Groq models are most reliable?
• Any failed_generation / 400 issues?
• Any settings that improved stability?

Thanks. Happy to share a quick test checklist if useful.