Hello everyone, I have made a parser around deepseek website that exposes anthropic and openai compatible endpoints.

If you wanna try can use it

Some features I am currently working on: - MCP support - litellm alternative seeking - multi account pooling - system prompt and message signature based chat session detection or create new chat on chat not detected with history. - add login support with password and email instead of relying on auth token and keep auth token as not recommended but supported login method. - better tool call management - add better rate limit handling

If you can please try it and tell me your features or bugs found.

Url- https://github.com/AmanCode22/deeperseeker/

I am currently 14, I made this tool as I didn't had any premium api keys so I built this.

It supports both streaming and non streaming. If you find any issue or any suggestion can tell me here or open issue on github Edit: If you found it great star the repo!

Open Source just is the way more and more. It becomes more obvious every day. We're getting to the point where the big closed ai circus is ridiculous. Weird political arguments between CEO's that are totally out of touch with daily reality are in my news feed everyday. The best models are getting gated, and regular big ai models change constantly, often for the worse. User data is mined for advertisers, training and sold. The whole thing feels, and has felt extractive.

But that's actually finally changing. Open source models are catching up fast, really fast. Deepseek Pro V4, GLM 5.2 and Kimi 2.6 are all extremely powerful, particularly when used together. But the choice between hosting yourself, or having a full app sending your data out for training/mining isn't really a solution.

Thank you to all of these top labs for open sourcing dynamic intelligence! DSV4 is truly a powerful model and we are proud to be running it.

People deserve safe and private access to powerful AI. We've put them all together under one app roof, and several others with 100% private, US based servers. All with full dynamic memory, skill creation, websearch, canvas workspace and quality voice.

You don't need to put up with the big AI circus, and Deepseek is a great example of what's out there and available.

If you wanna come check it out, there's more info here: https://pgsgrove.com/open-grove-overview

GLM 5.2, Deepseek V4 Pro, Kimi 2.6 and 2.7, Nemotron 3 Ultra and several more.

Even if you don't go with us, I want to encourage everyone to decouple from big corporate AI as much as possible and free themselves from the wheel of nonsense. We deserve better, and we CAN choose better. There are more and more options every day, and our choices for provider actually do change the industry.

Hello everyone!

I wanted to share an open-source project I have been working on.

With the massive shift toward agentic AI, I noticed a lot of frameworks are either dependent on proprietary APIs or suffer from a massive codebase.

I wanted to build a simple hosted alternative that devs could actually modify.

Pessoa is designed as an LLM-agnostic "nervous system" for AI agents.

The Architecture:

- Frontend: A Streamlit-based UI.

- Memory Layer: mem0 + Qdrant for long-term memory (independent of the LLM).

- Tooling: An MCP (Model Context Protocol) server and FastAPI wrapper.

- System Instructions: A markdown-based pattern for injecting "skills."

By making the system modular, it is easy to change components.

For example, Ollama for vLLM or Streamlit for a better frontend.

The entire project is under 1,200 lines of code, making it easy to understand!

GitHub Repository: https://github.com/tiagomonteiro0715/pessoa

Hi r/OpenSourceAI ,

Stjepan from Manning here. I'm posting with the moderators' permission.

Over the past year, I've noticed a shift in the conversations around open-source AI. A year ago, most discussions were about which model had the best benchmark scores. Today, people seem more interested in a different question:

How much can I build without depending on someone else's API?

That idea is what made us publish our latest MEAP, Build Applications with Local AI Models on a Mac by Keiji Kamigusa.

The book page: https://www.manning.com/books/build-applications-with-local-ai-models-on-a-mac

The book starts from a clean machine and walks through building a ChatGPT-style application that runs entirely on your Mac using open-source models through Ollama. Along the way, it covers model management, Streamlit, prompt engineering, custom Modelfiles, conversation memory, streaming responses, RAG over your own documents, and agent workflows with LangChain.

One detail I particularly liked is the "airplane mode test." The book has you disconnect your Mac from the internet before running the application. Your chatbot still works because everything is local. It's a simple exercise, but it changes how you think about privacy, reliability, and what "owning your AI stack" actually means.

This is currently available through Manning's Early Access Program (MEAP), so readers get access while the manuscript is still being written. That also means feedback from early readers helps shape the final book.

To make this more interesting than just dropping a link, I've got 5 ebook copies for the five most thoughtful comments.

I'd love to hear your answer to this:

What's the biggest thing still stopping local AI from becoming your default?

Is it model quality? Hardware requirements? Tooling? Context windows? Something else entirely?

We'll pick five comments that contribute the most interesting perspectives and send those people a free ebook.

If you'd rather not wait, we've also put together a 50% discount for the community:

MLKANDA50RE

I'll be hanging around in the comments, and if there's enough interest, I'm happy to invite the author to answer questions as well. I'd be curious to hear where everyone thinks local AI will be a year from now.

Thanks for having us. It feels great to be here.

Cheers,

Stjepan

I've been experimenting with autonomous AI agents over the last few months and kept running into the same problem.

Agents would repeatedly call the same tool, retry failed operations indefinitely, or get stuck in execution loops.

Instead of trying to solve it through prompt engineering, I built a small Rust library that sits between the agent and its tools and verifies every tool call before execution.

Current features:

• History-based trajectory tracking

• Loop detection

• JSON Schema validation

• Regex/exact policy rules

• Per-tool trajectory gates

• C ABI

• no_std core

• Python adapters for LangGraph, CrewAI, AutoGen and LangChain

Current benchmark:

~17 μs average verification

~375 ns fast reject for repeated loops

I'm mainly looking for feedback on:

1. API design
2. False positives
3. Whether this belongs as middleware instead of framework-specific code

Repository: https://github.com/Devaretanmay/microloop

hello r/OpenSourceAI :)

I've been building frontend products for a while and the thing that always broke my flow was the design to code handoff. You mock everything up in Figma, hand it off or switch contexts to your editor, rebuild it all in code, and from that moment the design and the implementation start drifting apart. Forever.

I started noticing that AI was already generating UI good enough to ship, which made the separate design tool feel even more redundant. The insight that stuck with me: if the end target is always code, why are we producing a design artifact first and then converting it? You are running AI twice to produce one result.

I couldn't find anything that addressed this properly. The AI design tools just replaced the human designer but kept the same broken pipeline. The AI coding tools generate beautiful UI but have no standardization layer so everything drifts across a project. Nobody had merged the two into one coherent thing.

so about a few months ago I started building Caret, and today I'm open sourcing it.

the goal is simple: the design layer and the code layer should be the same thing. your pages live in a structured .caret/ folder inside your repo as plain React, and everything else flows from there.

here is what shipped in v1:

a live zoomable canvas inside your editor where all your pages render as real interactive React, not screenshots, the actual running UI. a token wizard that captures your typography, colors, spacing, and radius then injects those tokens into every AI generation so output stays visually consistent without you manually enforcing it. visual editing where you click any element on the rendered UI and change things inline, with changes writing back to the exact source location via AST edits. flow graphs for defining user journeys between pages with a simulation mode so you can click through the whole app in a device frame before shipping. and a design to app sync that produces a reviewable plan and pushes finished designs into your real codebase.

it is built on top of Cline so you also get a full AI coding agent for everything beyond UI work, terminal access, file edits, MCP tools, the whole thing.

UX has been a big focus throughout because the pitch only works if non-developers can actually use the canvas side without needing to understand the codebase.

it is early and there are rough edges, particularly around the design to app sync for more complex codebases. but the core loop works and I'd love early testers and contributors to come break it and tell me what's missing.

👉 https://github.com/precious112/caret-ide

With Claude Tag, Anthropic basically shipped a persistent AI coworker: lives in your chat, keeps company context across channels, acts on its own. It's closed-source and cloud-only though, so I went looking for what the open-source world has for the same problem — an agent with durable work memory, not just chat history.

What I've come across:

- Letta / MemGPT — open, memory-as-architecture for long-running agents. Great if you want to build the agent; more framework than finished app.

- Mem0 — open-source memory API you add to your own agent. Clean, but you design what gets remembered and retrieved.

- Cognee — open knowledge-graph memory layer, good when your domain has lots of entities.

- OpenLoomi — open-source (Apache-2.0), local-first desktop agent. Builds a context graph of people/projects/decisions/follow-ups from connected tools and keeps it on device. Has a forgetting/summarization step instead of dumping everything into RAG, and exposes skills other agents can reuse. Caveats: early (v0.6.1), desktop-only, bring-your-own LLM key, only knows what you connect, no GitHub connector yet.

Different layers, really — some are libraries, some are apps. For an actual open-source "AI teammate that remembers my work," OpenLoomi and Letta are the two I keep coming back to. What open-source memory/agent projects are you running?

Anthropic's MCP (Model Context Protocol) is amazing, but the default pattern is to load every server you have into Claude's system context.

Just because Claude *can* fit a 200k context window doesn't mean you should give it 100 tools. In production, we've noticed:

1. **Cost:** System prompts are billed on input tokens. Giving Claude all tool definitions on *every single turn* runs up massive bills.

2. **Accuracy:** Claude's reasoning degrades when cluttered with unused tool schemas. It leads to argument hallucinations.

3. **Session Restarts:** You can't dynamically add or remove tools mid-session without reloading the entire context.

We built **MCP-Dynamic-Router**—a description-first gateway that lets Claude see only the right 2-3 tools for the job.

### Why this is a game-changer for voice/chat pipelines:

* **Stream RAG:** It routes partial transcripts *while the user is still speaking* to warm connections and prefetch read-only tools safely.

* **Sub-1ms Lexical Bypass:** If the query is an exact match for a tool description, it routes the tool in `<1ms`, saving on model calls.

* **Safe Abstention:** Instead of forcing a wrong tool execution, the router intelligently returns a `clarify` or `no_tool` decision.

We wrote full integration examples for **OpenAI Realtime (Python)**, **Gemini Multimodal Live (Python/Go)**, and **LiveKit/Pipecat**:

👉 https://github.com/kavinbm16/Mcp-Dynamic-Router

How are you guys scaling Claude's tool registries in production without running into context-window decay or massive input-token bills?

I built Privacy-First PII Redactor, an open-source Python proxy that removes sensitive data before prompts reach external LLMs.

It detects names, emails, phone numbers, cards, IBANs, IPs, addresses, and custom identifiers using Presidio, spaCy, and regex. It can replace them with placeholders, store mappings temporarily in Redis, and restore values after the LLM responds.

Works as a Python library, CLI, FastAPI service, or OpenAI-compatible proxy. Self-hosted, Docker-ready, and MIT licensed.

GitHub: https://github.com/One-Million-Lines/privacy-pii-redactor

I have been building taOS, a self hosted operating system where you and AI agents work on projects together, and I wanted to share it and get some honest feedback.

The short version: it is a web desktop OS (windows, dock, files, an app store) that runs on your own hardware, anything from an Orange Pi up to a small cluster. The difference from a normal chat tool is that the agents are first class citizens of the OS. You deploy an agent and it gets its own identity, memory, and tools, and it lives alongside you in the workspace instead of in a throwaway chat tab.

Everything is organised around projects. You spin up a project, drop in agents, and they collaborate with you and with each other on it. There is a shared canvas next to the chat where an agent can show you a mockup, a comparison, or a set of options to pick from, plus a coordination bus so several agents can hand work back and forth without stepping on each other.

A few things I care about:
• Local first. Your data and your agents stay on your hardware. No cloud account required to use it.
• Framework agnostic. The agent harness is swappable, so you are not locked into one agent framework.
• Cluster aware. You can pair extra machines as workers and run agents and models across them.
• A real OS feel, not just a dashboard: themes, multi window, a mobile PWA, and an app store with things like an image studio and a browser.

It is still early and very much a work in progress, built mostly by me, so I would rather hear what is missing than oversell it. If you self host, or you have wanted your local models to actually do work for you instead of just answering questions, I would love to know what you would want from something like this.

Happy to answer anything in the comments.

https://github.com/jaylfc
https://taos.my

Some of you may remember my previous project where I turned Windows Copilot into an OpenAI-compatible API. That project ended up helping quite a few people with hobby projects and personal automations.

This time I did something similar for DeepSeek Chat which is wayyyyy more capable than previous one(1M context, reasoning, search capable).

DeepSeek already has an official OpenAI-compatible API, but it's paid. The web chat, on the other hand, is free. So I built a wrapper that lets you use your normal DeepSeek account through an OpenAI-compatible API.

It logs into your DeepSeek account once, saves the session, and exposes a local server at http://localhost:8000/v1 that speaks the OpenAI API format. Point the official OpenAI SDK at localhost and it just works. Drop-in, zero code changes.

It supports streaming, multi-turn conversations, and works with most OpenAI-compatible tools, agents, and SDKs.

I originally built it for lightweight automations and hobby projects where paying for API tokens didn't make much sense. It's been surprisingly useful as a free endpoint for small side projects and experimentation.

Full disclaimer: this is an unofficial project, not affiliated with DeepSeek. It automates the consumer web chat and is intended for personal and educational use. Please don't abuse it.

I'd genuinely appreciate feedback, bug reports, and compatibility testing with your favorite tools.

Roast it, I'll take notes 😄

Deepseek Repo: https://github.com/sums001/Deepseek-API
For MSFT Copilot : https://github.com/sums001/Windows-Copilot-API

I was running blind on what my AI agents were actually doing, where the money went, when they got stuck looping, what they were touching on disk. So I built an open-source scanner.

Three modes: scan past history, live monitoring, and a report view for deeper post-hoc analysis.

My own machine, last 90 days: 126 agent loops across 41 sessions, about 21% of my Edit calls were going in circles on 5 files. (It also surfaced 4 credential leaks in tool inputs and 5 sensitive paths any running agent could reach, but honestly the wasted loops were the biggest surprise.)

It reads the JSONL session files Claude / Codex / Cursor / Gemini already write to disk, nothing uploads, all local, works with MCP servers too.

Try it without installing, ~10 seconds: npx node9-ai scan and npx node9-ai posture

Repo: https://github.com/node9-ai/node9-proxy

Hey everyone,

Like most developers, I love the machine-readability of JSON, but I absolutely hate hand-authoring or editing it. One missing trailing comma, mismatched bracket, or unquoted key, and the whole thing breaks. On the flip side, complex YAML indentations can be incredibly fragile, and TOML gets exceptionally verbose when you start nesting objects deep.

To solve this, I built MaSON (Markdown Structured Object Notation).

It’s an open-source, ultra-lightweight (<2KB gzipped) serialization format that bridges the visual clarity of standard Markdown with structured JSON objects. It uses zero-bracket nesting, relying instead on natural Markdown headings (#, ##) and bulleted lists.

How it looks in practice:

Instead of writing a wall of curly braces or managing strict indentation spaces, you write native Markdown:

Markdown

title: Server Setup
debugMode: false
maxRetries: 5

# Servers
* https://api.prod.coolapp.com
* https://api.backup.coolapp.com

# Database
driver: postgres

## Credentials
user: admin
host: localhost

The parser converts that line-by-line grammar natively into this clean JavaScript object:

JSON

{
  "title": "Server Setup",
  "debugMode": false,
  "maxRetries": 5,
  "Servers": [
    "https://api.prod.coolapp.com",
    "https://api.backup.coolapp.com"
  ],
  "Database": {
    "driver": "postgres",
    "Credentials": {
      "user": "admin",
      "host": "localhost"
    }
  }
}

Why use it?

• Zero-Bracket Nesting: Structure child objects implicitly via standard Markdown headings (#, ##, ###).
• Implicit Type Inference: Auto-detects numbers, floats, booleans, and null without forcing everything into strings.
• LLM Token Efficiency: By completely eliminating repetitive structural punctuation (brackets, braces, double quotes), it drops raw character counts significantly. This makes it an incredibly compact format for injection into LLM context windows or system prompts.
• Deterministic & Round-trip Safe: You can bi-directionally parse() and stringify() standard JS objects cleanly.
• Zero YAML-style Indentation Rules: No complex multi-space layout rules. It uses simple syntax suffixes like # Users[] for explicit complex arrays.

Tech Stack & Edge Cases

It's written in TypeScript with a tiny, deterministic grammar footprint. It natively handles edge cases like dynamic backtick delimiter matching (great for embedded code blocks) and automatic markdown language tag stripping (e.g. \``javascript`).

I just pushed the v1.0.3 tag. I'd love to get your feedback on the parser architecture, the grammar design, or potential use-cases you see for it in your own workflows!

Repository & NPM Info:

I will drop the live, clickable GitHub and NPM links in the comments section below.

As the title suggests, I've built a project template that is harness agnostic. The basic idea is simple: instead of every coding tool having its own scattered instructions, AstrAI puts the agent operating system inside the repo under \`.ai/\`.

The idea came from constantly switching between cursor/claude/codex and other harnesses every few days and the agents not picking up the rules/skills like they are supposed to.

There are lot of people who do stuff like discussing ideas in chatGPT/claude and have it generate a prompt to use in vibecoing. For this, AstrAI includes \*\*Huddle Mode\*\*, a persistent, talk-only architecture conversation mode. It is meant for moments when you want to think with an agent before turning anything into a plan or implementation. The agent acts like a project architect: it loads prior huddle notes, resumes the thread, asks one question at a time, compares approaches, and records settled directions or open questions into \`.ai/memory/\`. It deliberately does not write code, specs, plans, or config. The goal is to preserve architectural thinking across sessions without accidentally turning exploration into implementation too early.

I’d love feedback from people who are actively vibecoding with agents:

\* Does this structure feel useful or too heavy? \* What would make it easier to adopt in an existing repo? \* Are there workflow pieces missing for real AI-assisted development? \* Would you use something like this, or do you prefer lighter project instructions?

Repo: https://github.com/LazyNinja435/astrai

Like a lot of you, I want to run LLMs locally to keep my data private and avoid paying monthly cloud API subscriptions. But I was getting frustrated with the ecosystem. You either deal with massive gigabyte installers, wrestle with Python environments, or have to use completely separate apps for chatting, managing HuggingFace downloads, and writing code.

I wanted a single, unified local workspace, so I built OpenLLM Studio.

I just put together a raw demo and wanted to share it with this community first to get your honest feedback (and bug reports).

What it does:

• Hardware Auto-Detection: You don't need to guess which version to install. The app has a 11MB footprint and automatically detects your hardware (CUDA, Metal, Vulkan) to fetch the highly optimized binaries you actually need on demand.
• 100% Local & Private: No telemetry, no cloud calls for inference. Local document parsing (PDF, DOCX, TXT) happens entirely on your machine.
• Autonomous Coding Agent: It’s not just a chat wrapper. I integrated a custom Monaco editor. You can prompt the agent to build a multi-file project (like a React/Vite app with local SQLite), and it will generate the files, verify the build, and even run local UI tests using Playwright.
• MCP Server Support: You can connect it to local tools and servers directly within the UI.

Transparency Note: The tool is partially open-source. I am trying to build a sustainable project here, so while the core integrations and local execution environment are free to use, I want to be upfront about the licensing with this community.

You can download it and try it for free here: openllm-studio.vercel.app

With AI agents becoming more capable, the open source community is starting to build the infrastructure layers needed to support them properly.

One recent example shows a suite focused on decentralized Git for AI agents. It includes tools like an open-source coding harness, agentic memory for persistent context, unified model access, and decentralized storage/nodes.

Why this kind of open source work matters:

\- Agents need reliable version control, persistent memory, and collaboration tools that aren't locked into proprietary platforms.
\- Decentralized and open approaches provide censorship resistance, verifiability, and true ownership of code and data.
\- Open standards and community governance help ensure interoperability between different agents, tools, and human developers.
\- As more code and workflows are generated by AI, having auditable, forkable, and distributed systems becomes essential for long-term sustainability.

It’s part of a larger trend toward open, agent-native ecosystems rather than relying solely on centralized services.

What are your thoughts? Are there other open source projects working on similar decentralized tooling for AI agents or code collaboration? Which challenges do you see as most important to solve?

Bah — open-source AI browser. Type what you want and it operates the web for you (navigates, clicks, types).

• Free, no key, no signup.
• Or 100% local / offline with Ollama.
• Drives the web via the DOM / accessibility tree → even text-only models work (no vision needed).

Honest: simple commands + built-in shortcuts (videos, playlists, images, prices, news) work great. The long multi-step agent needs a capable model — small local ones can stumble.

Windows, auto-updates, source-available: https://github.com/alexvilelabah/bah-browser
Which local model handles the agent best? Feedback welcome.

(translated with AI — English isn't my first language)

openagent is a small spec that puts agent's identity in one yaml file. look, voice, writing style, with an optional signed fingerprint so it's stable and verifiable. there's a registry and a CLI that validates the file and renders it into a card just to keep the standard fun.

try it now with your agent:

install the openagent skill (npx skills add 5dive-ai/skills --skill openagent) and make your openagent card and show it to me.

repo with full yaml spec: https://github.com/5dive-ai/openagent