LM Studio

LM Studio AI

LM Studio AI

LM Studio AI

LM Studio AI

LM Studio AI

LM Studio AI

LM Studio AI

LM Studio AI

LM Studio AI

LM Studio AI

PrimeTask Bring Your Own AI - Claude sets up a full project in one prompt.

Hey r/ClaudeAI, I'm one of the developers behind PrimeTask, a local-first productivity system for macOS. The final beta now ships with Bring Your Own AI, a local MCP server (110+ tools, 5 prompt templates) so you can point Claude Desktop, Claude Code, Cursor, or LM Studio at it and let your own agent do the work. Quick demo in the video. One sentence from me, end-to-end project setup from Claude. What's happening in the clip I say I'm launching a Mac app in six weeks and ask Claude to set up the project. Claude creates the project with a deadline, three phase tasks (Design, Build, Launch) with staged due dates, descriptions, tags, subtasks, and short checklists. Sets a reminder on the first task so the native macOS toast fires during the recap. Recommends where to start. I say "start." Claude moves Design into the Design status and kicks off a timer. Twelve-plus tool calls under one prompt. No copy-paste, no manual setup. Why BYO AI (not a bundled cloud bridge) Server runs inside PrimeTask on your Mac. Your tasks, projects, CRM, and notes never leave the device. We don't ship a model. You bring your own: Claude Desktop, Claude Code, Cursor, LM Studio, anything MCP-compatible. No Anthropic-side context about your work. Claude only sees what your agent pulls in per turn. Per-space permissions: lock an agent to read-only or scope it to one workspace. Streamable HTTP with Bearer auth, or stdio if you prefer that route. Tool catalog profiles (Full, Core Tasks, Minimal, PrimeFlow, CRM, etc.) so smaller local models don't get drowned in 100+ tools. Five built-in MCP prompts (daily_standup, weekly_review, project_status, crm_summary, overdue_triage) for the workflows people actually want. Every tool call is logged in an in-app audit log. Full BYO AI docs (setup, transports, tool catalog, security): https://www.primetask.app/docs/integrations/bring-your-own-ai Why we built it this way Most "AI in your task app" is the app calling a vendor's API on your behalf, often with your data going through their pipes. We wanted the opposite. Your agent, your model, your machine. The app exposes a tool surface and gets out of the way. That's what BYO AI means here. PrimeTask itself is local-first, no account, no subscription, plain JSON on disk. BYO AI made the AI story consistent with that: nothing leaves your laptop unless you point your agent at one that does. Where we're at PrimeTask is wrapping up the final beta and heading to a stable launch this summer. Beta is now closed to new sign-ups. We're locking it down to ship the stable release. If you'd like to be notified at launch, drop your email here: https://www.primetask.app/notify or visit https://www.primetask.app Happy to answer questions about the MCP setup, the profile system, or how we structured the tool descriptions for agent discoverability. submitted by /u/XVX109 [link] [comments]

How I used Claude Code (and Codex) for adversarial review to build my security-first agent gateway

Long-time lurker first time posting. Hey everyone! So earlier this year, I got pulled into the OpenClaw hype. WHAT?! A local agent that drives your tools, reads your mail, writes files for you? The demos seemed genuinely incredible, people were posting non-stop about it, and I wanted in. I had been working on this problem since last year and was genuinely excited to see that someone had actually solved it. Then around February, Summer Yue, Meta's director of alignment for Superintelligence Labs, posted that her agent had deleted over 200 emails from her inbox. YIKES. She'd told it: "Check this inbox too and suggest what you would archive or delete, don't action until I tell you to." When she pointed it at her real inbox, the volume of data triggered context window compaction, and during that compaction the agent "lost" her original safety instruction. She had to physically run to her computer and kill the process to stop it. That should literally NEVER be the case with any software ever. This is a person whose actual job is AI alignment, at Meta's superintelligence lab, who could not stop an agent from deleting her email. The agent's own memory management quietly summarized away the "don't act without permission" instruction, treated the task as authorized, and started speed-running deletions. She had to kill the host process. That's when I sort of went down the rabbit hole, not because Yue did anything wrong, but because the failure mode was actually architectural and I knew that in my gut. Guess what I found? Yep. Tons more instances of this sort of thing happening. Over and over. Why? Because the safety constraint was just a prompt. It's obvious, isn't it? It's LLM 101. Prompts can be summarized away. Prompts can be misread. Prompts are fucking NOT a security boundary. And yet every agent framework I have ever seen seems to be treating them as one. I went and read the OpenClaw source code, which I should have done to begin with. What I found was a pattern I think a lot of agent frameworks have fallen into: - Tool names sit in the model context, so the model can guess or forge them - "Dangerous mode" is one config flag away from default - Memory management has no concept of instruction priority - The audit story is mostly "the model thought it should" I went looking for a security-first alternative I could trust, anything that was really being talked about or at a bare minimum attempted to address the security concerns I had. I couldn't find one. So I made it myself. CrabMeat is what came out of that, what I WANTED to exist. v0.1.0 dropped yesterday. Apache 2.0. WebSocket gateway for agentic LLM workloads. One design thesis: The LLM never holds the security boundary. What that means in code: Capability ID indirection. The model doesn't see real tool names. It sees per-session HMAC-derived opaque IDs (cap_a4f9e2b71c83). It can't guess or forge a tool name because it doesn't know any tool names. Effect classes. Every tool declares a class (read, write, exec, network). Every agent declares which classes it can use. The check is a pure function with no runtime state, easy to test exhaustively, hard to bypass. IRONCLAD_CONTEXT. Critical safety instructions are pinned to the top of the context window and explicitly marked as non-compactable. The Yue failure mode, compaction silently stripping the safety constraint, cannot happen by construction. The compactor literally cannot touch them. Tamper-evident audit chain. Every tool call, every privileged operation, every scheduler run enters the same SHA-256 hash-chained log. If something happens, you can prove what happened. If the chain is tampered with, you can prove that too. Streaming output leak filter. Secrets are caught mid-stream across token boundaries, capability IDs, API keys, JWTs, PEM blocks redacted before they reach the client. No YOLO mode. There is no global "trust the LLM with everything" switch. There never will be. Expanded reach comes through named scoped roots that are explicit, audit-logged, and bounded. The README has 15 'always-on' protections in a table. None of them can be turned off by config, because these things being toggleable is how the ecosystem ended up where it is. I decided to make sure that this wasn't just a 'trend hopping' project and aligned with my own personal values as well. I built this to be secure and local-first by default. Configured for Ollama / LM Studio / vLLM out of the box. Anthropic and OpenAI work too but require explicit configuration. There is no "happy path" that silently ships your prompts to a cloud endpoint. I decided that FIRST it needed to only run as an email agent with a CLI. Bidirectional IMAP + SMTP with allowlisted senders, threading preserved, attachments handled. This is the use case that bit Yue and a lot of other people, and I wanted to prove it could be done with real boundaries. I added in 30+ built-in tools of my own. File ops, shell (denylisted, output-capped, CWD-lo

LLM-Rosetta — format conversion library across LLM API standards, doubles as a proxy

This started because we had a proprietary internal LLM API that spoke none of the standard formats. Built an internal conversion layer to bridge it, maintained that for over a year. As colleagues started adopting more and more coding tools — Claude Code, opencode, Codex, VS Code plugins, Goose, and whatever came out that week — each with its own API format expectations, maintaining separate adapters for each became the actual problem. That's what pushed the internal conversion layer into a proper generalized design, and llm-rosetta is the result. It's a Python library that converts between LLM API formats — OpenAI Chat, Responses/Open Responses, Anthropic, and Google GenAI. The idea is you convert through a shared IR so you don't end up writing N² adapters. The key difference from LiteLLM: LiteLLM is a unified calling layer that takes OpenAI-style input and transforms it into provider-native requests — one direction. llm-rosetta uses a hub-and-spoke IR, so each provider only needs one converter, and you get any-to-any conversion for free. Anthropic → Google, OpenAI Chat → Anthropic, whatever direction you need. Use it as a library — pip install and call convert() directly, no server needed. Or run the gateway if you want a proxy that handles the format translation for you. Zero required runtime dependencies either way. The HTTP server, client, and persistence layer are vendored from zerodep (https://github.com/Oaklight/zerodep), another project of mine — stdlib-only single-file modules, not someone else's library repackaged. The gateway ships with a Docker image if you'd rather not deal with Python env setup. You can also deploy it on HuggingFace Spaces or anything similar — admin panel, dashboard, request log, config management all included. Screenshots: https://llm-rosetta.readthedocs.io/en/latest/gateway/admin-panel/ We've been running it in production for about 5 months as the conversion layer for an internal multi-model access platform — needed to support various API standards and coding tool integrations before the upstream APIs were fully standardized. The Responses converter passes all 6 official Open Responses compliance tests (schema + semantic) from the spec repo. So if you're running Ollama, vLLM, or LM Studio with Responses endpoints, it should just work as one side of the conversion. There's a shim layer for provider-specific quirks — built-in shims for OpenRouter, DeepSeek, Qwen, xAI, Volcengine, etc. Converters stay generic per API standard, shims handle the edge cases declaratively. 24 cross-provider examples in the repo covering all provider pairs, SDK + REST, streaming, tool calls, image inputs, multi-turn with provider switching mid-conversation. GitHub: https://github.com/Oaklight/llm-rosetta Docs: https://llm-rosetta.readthedocs.io arXiv: https://arxiv.org/abs/2604.09360 Gateway screenshot: https://preview.redd.it/qzzjr2dcdw1h1.png?width=949&format=png&auto=webp&s=bce4293aae81059f794909fc37f85071cee34378 submitted by /u/Oaklight_dp [link] [comments]

Most of my Claude usage was on work that didn't need Claude. Cut my bill 60x on bulk tasks with a tiny side model.

I looked at what was actually eating my Claude usage and it was embarrassing. Classifying files. Reformatting json. Pulling fields out of text. Summarizing docs I was going to skim anyway. None of that needed Sonnet. All of it cost the same as the work that did. Tried the obvious fixes first. Switching to Haiku for simple stuff (still wasteful at volume). Tighter prompts (helps a little). /compact (delays the problem). None of it changed the shape of the spend. What actually worked: a small cheap model running as a side worker, with one rule in CLAUDE.md telling Claude not to do the mechanical stuff itself. The setup is one tool. Send it text, get text back. Claude calls it for the bounded mechanical work I'd review anyway. Default model is DeepSeek V4 Flash because it's cheap and has 1M context, but the endpoint is one config line and works with anything openai-compatible (local ollama, vllm, lm studio). 3 weeks of real usage: 217 mechanical calls offloaded DeepSeek total spend: $0.41 Same workload on Sonnet would have been roughly $7 The CLAUDE.md rule that actually works is negative framing. Not "use deepseek for X" but "do NOT use Claude for: json formatting, field extraction, file classification, summarization you will review anyway." Positive framing got ignored maybe 30% of the time. Deny list catches it. It's a supervised worker, not an agent. No tool calls, no file access, no chains. Latency 3-25s. You review the output. That's the whole shape. Repo with setup steps: https://github.com/arizen-dev/deepseek-mcp (MIT, Python 3.10+) Happy to answer questions about the routing rules or the model choice. submitted by /u/petburiraja [link] [comments]

claudely: launch Claude Code against Local LLM provider like LM Studio / Ollama / llama.cpp without trashing your real claude config

Plenty of CLI coding agents will talk to a local LLM, but the catch is the ecosystem. Skills, slash commands, MCP servers, plugins, hooks: all the interesting tooling has been built specifically for Claude Code, and parity on every other agent is patchy at best. Trying to reuse a Claude-shaped workflow on a different agent quickly turns into "rewrite all the plugins" or "do without." claudely skips that fight. You keep Claude Code as the client (and its whole plugin / skill / MCP ecosystem with it), and just point it at a model running on your own hardware. Pick a provider, claudely spawns `claude` with the right base URL, auth, and cache fix wired up for that one session. Your shell and the regular `claude` command stay untouched, so you can flip between local and the real Anthropic API without thinking about it. It also quietly fixes a prompt-cache bug that otherwise tanks local-model speed by ~90%, and handles the per-provider env-var differences for you. Works with LM Studio, Ollama, llama.cpp, or any Anthropic-compatible endpoint (point it at a litellm or claude-code-router proxy for OpenAI-protocol backends like vLLM). npm i -g claudely claudely # LM Studio, picker over your downloaded models claudely -p ollama -m gpt-oss:20b # Ollama, skip the picker claudely -p llamacpp # whichever GGUF llama-server is serving MIT, Node 20+, unaffiliated community helper. Built with Claude Code's help, fittingly. Feedback welcome. Repo: https://github.com/mforce/claudely NPM: https://www.npmjs.com/package/claudely submitted by /u/mforce22 [link] [comments]

Lessons from building a coding agent for 8k context windows: token budgeting, parallel executors, and per-file isolation

Most AI coding tools (Cursor, Aider, Claude Code) assume you have a 200k-token model. If you're running local LLMs through Ollama or LM Studio, or hitting free-tier cloud APIs like Groq or OpenRouter, you've got around 8k tokens to work with. That doesn't fit a whole project, barely fits a single large file. I spent the last few weeks building a CLI coding agent that's designed around the 8k constraint instead of fighting it. Wanted to share what I learned, because some of it surprised me. The core insight: the LLM never needs to see your whole project. Most agents try to stuff as much context as possible into a single call. With 8k tokens that's a non-starter. The approach that worked for me is splitting the work into roles: A planner call that only sees a lightweight project map (Markdown summaries of each folder, ~300-500 tokens for the whole project) plus the user's request, and outputs a task list. Executor calls that each see exactly one file plus one task. Never two files in the same call. An orchestrator that's pure code, absolutely no LLM, building a dependency graph between tasks and deciding what runs in parallel vs sequential. This split means the LLM only ever reasons about a small, bounded amount of code at any one time. The planner doesn't need to see code at all (just file summaries), and the executor only sees one file. Multi-file refactors stop being a context-window problem and become a scheduling problem. Token budgeting has to be enforced in code, not promised in a prompt. Every LLM call goes through a canFit() check that measures: system prompt + reserved output tokens + memory + actual code. If the code doesn't fit, the agent automatically falls back to a per-file line index (generated once for files over ~150 lines) and pulls only the relevant section. Concrete budget math for 8192 tokens: System prompt + instructions: ~1000 Reserved for response: ~2000 Short-term memory (4 entries): ~360 Available for actual code: ~4800 (about 140-190 lines) Parallel execution is the speed multiplier that makes 8k usable. Because each executor sees only one file, independent edits across files can run simultaneously. A 5-file refactor that would be slow if run sequentially completes in roughly the time of the longest single edit. The dependency graph (built in pure code from the planner's task list) decides which tasks have to wait for which. A few things that tripped me up along the way: Question-style requests overwriting files. The first version had no concept of read-only operations, so asking "how many lines does X have?" caused the executor to write the answer into the file. Fixed by adding an action_type: "query" field to the planner's output that routes through a separate code path that never touches disk. Stale project maps causing silent misroutes. If the user named a file in their request that wasn't in the context map (because they just renamed it, or hadn't refreshed), the planner would silently route the action to the closest match. Now the orchestrator validates that mentioned file paths actually exist on disk and throws a clear error if they don't. Markdown fences in executor output. Even when explicitly told not to, smaller models love wrapping code in triple backticks. Strip them in post-processing rather than fighting the prompt. Memory token cost. Initially didn't budget for it; persistent memory is great but it's another ~80-90 tokens per entry that has to come out of the code budget. Now folder context is dropped first when the budget is tight, then memory, before the actual code gets cut. What I'm still figuring out: Whether the planner/executor split scales cleanly to codebases over 50 files. The dependency graph stays manageable, but the project map starts costing real tokens once you have enough folders. Currently dropping folder context first when budget is tight, but that means deeper edits get less context. Curious if anyone else has run into this and how they handle it. Open-sourced the implementation if anyone wants to dig in: https://github.com/razvanneculai/litecode submitted by /u/BestSeaworthiness283 [link] [comments]

How can I run the model locally?

I want this ai to use for scripting but I tried installing it on lm studio but the model is nothing close to the real one can someone help submitted by /u/animehater69 [link] [comments]

I built a local-first memory layer for Claude Code — persistent sessions, knowledge graph, 27 MCP tools [open source]

**Nexus - The Cartographer** is a local-first plugin for Claude Code that gives every session persistent memory, a decision knowledge graph, and an optional local-AI strategist running against your own project state. Been building it for ~6 weeks. Hit v4.5.2 today and figured it was worth sharing — the problem it solves is one I kept hitting: **Claude forgets everything between conversations** . What it actually does Every session auto-logs decisions, blockers, fuel usage, and files touched **Knowledge graph** of architectural decisions with typed edges (led_to, depends_on, contradicts, replaced, informs, experimental) — blast-radius analysis when you're about to change something foundational **Thought Stack** push context before an interruption, pop when you return (survives session boundaries) **Local Overseer** via LM Studio — strategic Q&A with the full project state pre-loaded, can scan your decision graph for contradictions via embedding shortlist → LLM classification **SessionStart hook** injects ambient telemetry (fuel %, git deltas since last session, test baseline, service heartbeats, Overseer snapshot) into Claude's context before you type your first prompt Technical bits - 27 native MCP tools - Claude calls them as naturally as Read or Grep, no shell-outs - Zero cloud dependencies — everything at `~/.nexus/nexus.json` - React 19 + Tailwind 4 dashboard (optional - MCP works standalone) - 228 Vitest tests, automatic version/tool-count drift guard across 12+ doc surfaces - One-click `.mcpb` bundle for Claude Desktop install - Tracks Max plan 5h session windows + weekly "All models" / "Sonnet only" limits separately, estimates burn rate, warns before you run out Install /plugin marketplace add kronosderet/Nexus /plugin install nexus@nexus-marketplace Or grab the `.mcpb` from GitHub releases and double-click in Claude Desktop. Honest limitations - Opinionated - leans into a nautical/cartographer metaphor. You'll see "landmark reached #123" instead of "task completed" in CLI output. Find/replace is one sed away if that's not your thing. - Overseer features need LM Studio or Ollama locally (~8 GB VRAM for the model I use). All the non-AI features work without it. - Windows-first because that's my dev box. Designed to be cross-platform but Linux/macOS paths are lightly tested. - No multi-user story yet - single developer, single machine. Why I'm posting Half to share, half to ask: **what are you using for persistent memory across Claude sessions?** I'd like to hear from anyone who's solved this differently - CC's built-in memory, a vector DB layer, something else. Interested in where this concept breaks down at scale. Repo: https://github.com/kronosderet/Nexus submitted by /u/KronosDeret [link] [comments]

Your Claude Pro/Max code is NOT protected like you probably think it is

Had a long conversation with Claude recently about privacy terms, and some things came up that I genuinely didn't know. Sharing in case others are in the same boat. TL;DR: Claude Pro/Max runs under Consumer Terms with opt-in training, 5-year retention, no DPA. For trade-secret code or GDPR-regulated work, the API with your own key (Commercial Terms, DPA, no training) is the clean option, but it costs meaningfully more than the flat-rate subs. Since September 28, 2025, Claude Free/Pro/Max accounts fall under Consumer Terms, which means: Training on your data is opt-in by default (you have to actively toggle it OFF) Data retention is 5 years if training is enabled (vs 30 days otherwise) No DPA (Data Processing Addendum) is provided for consumer accounts "Extra usage" billing on Pro/Max still falls under Consumer Terms, not Commercial Terms This is different from what many of us remember from Anthropic's earlier "we don't train on your data" messaging. That old narrative is still circulating everywhere, but the policy changed quietly in a week when Anthropic was also announcing bigger news. Why this matters beyond just training: Even with training opted out, your data is still: Processed through safety classifiers (results stored, even under Zero Data Retention) Subject to manual review on suspected policy violations Retained for 30 days minimum on API, or 5 years on Consumer with training on Not covered by a DPA unless you're on Commercial Terms For anyone with a business-critical codebase: If your code is a trade secret under EU's trade secret laws (GeschGehG in Germany) or similar frameworks, "reasonable protection measures" are a legal requirement. Feeding proprietary code into a Consumer-tier AI service without a DPA is arguably NOT a reasonable measure, which can weaken your IP position in disputes, acquisitions, or due diligence. What's actually clean: Anthropic API with your own key → Commercial Terms, no training, DPA available via Console Claude Code via API key (not via Pro/Max sub) → same OpenCode or any other tool with your own API key → same Local models via Ollama/LM Studio → nothing leaves your machine What's problematic: Claude Pro/Max subscription for work on proprietary code "Extra usage" bolted onto Pro, which still runs under Consumer Terms Any consumer AI tool for IP-sensitive work without actively verifying terms The cost reality: Going API-only is noticeably more expensive than a Pro/Max flat rate for active coding use. Anthropic themselves report an average of ~$6/day per Claude Code developer, with 90% under $12/day and intensive agent use hitting $20-50/day. Compare that to Pro at $20/month or Max at $100-200/month and it's not a small difference, we're talking potentially 2-5x the cost depending on your usage profile. Takeaway: The "we don't train on your data" reputation is outdated and the policy change was under-communicated Tool-level flexibility (e.g. OpenCode) means you can swap providers if policies shift again The API premium buys Commercial Terms, DPA, no training, proper GDPR standing, and trade secret protection, which may or may not be worth it depending on what you're building If you're running a real business on Claude, the difference between Consumer and Commercial Terms is bigger than the marketing suggests, and worth understanding before you ship more proprietary code through it. Check your Privacy settings on claude.ai today. Make sure the training toggle is off. And if you're doing anything business-critical, weigh whether the API + DPA route is worth the price bump for your situation. submitted by /u/aldipower81 [link] [comments]

Turned Claude's rough week into an excuse to build an OpenCode-compatible version of my D&D skill

Claude has had a rough week. Between the outage and the usage limit threads, I figured it was actually good timing to do something I had been meaning to try anyway: take the D&D skill I built a few weeks ago and see if I could migrate it to run on OpenCode with free or local models. If Claude is your DM and Claude goes down mid-session, that is a problem worth solving. The short version: it works, and it was easier to set up than I expected. What I built open-tabletop-gm is a fork of the original claude-dnd-skill, rebuilt to run on any LLM through OpenCode. OpenCode supports Anthropic, OpenAI, Google, Ollama, LM Studio, and any OpenAI-compatible endpoint, so you can point it at whatever is available. Free tier models, local models, a different provider entirely. The Claude-specific parts (model routing between Haiku/Sonnet/Opus, the ~/.claude/ path structure, autorun) have been replaced with portable equivalents. The campaign files, display companion, and Python toolchain are all identical. While I was at it, I also pulled D&D 5e out of the core and turned it into a system module. The GM core (pacing, NPC craft, improvisation, consequences) lives in one file and knows nothing about any specific game. D&D 5e lives in a separate systems/dnd5e/ folder. If you want to run Vampire: The Masquerade, Cyberpunk RED, Pathfinder, or any other TTRPG, you write a system.md describing your game's dice resolution, stats, health model, and conditions - and the same GM core runs it. There is a porting guide covering what transfers directly from the D&D implementation vs what needs configuring per game. D&D 5e is the reference implementation and ships fully built out. Everything else is a system.md away. Why smaller/free models hold up better than you might expect The Python toolchain carries a lot of the weight that would otherwise fall on the model: Dice rolls, HP math, damage tracking: Python Initiative and turn order: Python, tracked in a live sidebar Timed effects and conditions: Python, file-persisted SRD data lookup (spells, monsters, items): local JSON The model's job is narration and judgment. It reads the campaign state from plain Markdown files and narrates from there. It does not do arithmetic and does not need to hold mechanical state in memory. That separation is what makes free and smaller models viable: the parts that tend to break on constrained models have been moved out of the model entirely. First test: MiniMax M2.5 via OpenCode Tested against the original claude-dnd-skill version. Setup was surprisingly frictionless -- OpenCode picked up the skill file without extra configuration. The model produced creative NPC responses and correctly read deceptive intent in a player message. More than I expected from a first pass on a free tier model. Current testing: Qwen3-32B via LM Studio Working well on the portable version so far. Script calls reliable, narration solid, campaign state persisting correctly across sessions. Testing is being pushed down toward Qwen3-14B to find the practical floor. Results going into the LLM guide as they come in. What stays the same Everything you already know from the original skill: persistent campaigns, the cinematic display companion you can Chromecast to a TV, character sheets, the DM philosophy, NPC memory, all of it. The system module architecture now lets you run any TTRPG, not just D&D 5e, by writing a system.md for your game. But if you are running D&D the experience is the same. Claude is still the better DM To be clear: this is not a "switch away from Claude" post. Claude Code with claude-dnd-skill is still the better experience. Better narration, model routing, deeper integration. If Claude is up and you have quota, use that. But having a version that works when it is not is genuinely useful. And honestly, testing it has been a good reminder of how much the Python toolchain is doing independent of any specific model. Links Repo: https://github.com/Bobby-Gray/open-tabletop-gm LLM guide (WIP): https://github.com/Bobby-Gray/open-tabletop-gm/blob/main/docs/LLM-GUIDE.md Original skill (Claude Code): https://github.com/Bobby-Gray/claude-dnd-skill submitted by /u/Bobby_Gray [link] [comments]

CLaude code locally Help please

I am looking to run Claude locally via LM Studio, and I’m currently stuck at the 'Select login method' prompt. Could someone please advise me on the optimal choice for this step? I have researched various solutions over the last few hours, but haven't been able to find any solution. https://preview.redd.it/3337alv41kvg1.png?width=1377&format=png&auto=webp&s=be33615b4daaa9ca827ce02d2c65112e72e3e513 Please, if anyone knows any solution submitted by /u/boymonster0 [link] [comments]

Bridge for Claude Code CLI to Google AI Studio Models

Claude Code is great. Anthropic credits disappear fast. Google AI Studio has a generous free tier. So I built a bridge between the two. It's a local server that intercepts Claude Code's API calls and forwards them to Gemini. Claude Code has no idea anything changed. --- Setup in 3 steps: git clone https://github.com/ThinkWario/gemini-claude-bridge cd gemini-claude-bridge pip install -r requirements.txt # Add your key to .env: GEMINI_API_KEY=your_key python server.py Then drop this in your project folder as .claude/settings.json: { "env": { "ANTHROPIC_BASE_URL": "http://0.0.0.0:8000", "ANTHROPIC_AUTH_TOKEN": "dummy", "ANTHROPIC_API_KEY": "", "ANTHROPIC_MODEL": "gemma-4-31b-it" } } Open Claude Code. Done. --- What works: Streaming, tool use, multi-turn, vision, extended thinking, prompt cache emulation, token counting — the full Anthropic API surface that Claude Code actually uses, all translated to Gemini under the hood. On startup you get a live model picker with every model in your Google AI Studio account — Gemini 2.5 Pro/Flash, Gemma 4, LearnLM, everything. Pick by number or type any name directly. Caveats: - It's Gemini under the hood — behavior and personality are Google's - Free tier rate limits apply (varies by model) Free API key: aistudio.google.com/app/apikey Repo: github.com/ThinkWario/gemini-claude-bridge --- Subreddits: r/ClaudeAI, r/LocalLLaMA, r/ChatGPTCoding submitted by /u/Rare_Travel_2147 [link] [comments]

Claude code requested features

1) allow local agents using Ollama and Lm Studio. local agents that will be used for simple tasks and questions while the more complex things will be done by the cloud 2) Claude code should have something Hermit self improving process and auto skills creation instead of manually making spec files submitted by /u/Least-Ad5986 [link] [comments]

I built CLI-Anything-WEB — a Claude Code plugin that generates complete Python CLIs for any website (17 CLIs so far: Amazon, Airbnb, TripAdvisor, Reddit, YouTube...)

Point it at a URL, Claude Code captures the live HTTP traffic, and generates a production-grade Python CLI with commands, tests, REPL mode, and --json output — fully automated across 4 phases. How it works Phase 1 (capture): Records live browser traffic via playwright-cli Phase 2 (methodology): Analyzes endpoints, designs architecture, generates CLI code Phase 3 (testing): Writes unit + E2E tests (40–60+ per CLI, all passing) Phase 4 (standards): 3 parallel Claude agents do compliance review, then publishes 17 CLIs generated so far No-auth public scraping: Amazon, Airbnb, TripAdvisor, Reddit, YouTube, Hacker News, GitHub Trending, Pexels, Unsplash, ProductHunt, FutBin, Google AI Auth-required: NotebookLM, Google AI Studio, Booking.com, ChatGPT, CodeWiki Example — built Amazon search in one pipeline run bash cli-web-amazon search "crash cart adapter" --json cli-web-amazon bestsellers electronics --json cli-web-amazon product get B002CLKFTQ --json Open source https://github.com/ItamarZand88/CLI-Anything-WEB The entire pipeline runs inside Claude Code using a 4-phase skill system. Anti-bot bypass is handled with curl_cffi impersonation (Chrome/Safari iOS) — no Playwright needed at runtime. Each CLI is a standalone pip-installable package. Happy to answer questions about the skill system, anti-bot patterns, or how the testing phase works. submitted by /u/zanditamar [link] [comments]

I gave AI it's own version of Reddit

So I had this idea — what if I ran multiple local LLMs simultaneously and let them loose on a Reddit-like forum where they could post, reply, and respond to each other completely autonomously? No cloud, no API keys, everything running on my own PC. Here is what I ended up building: A full stack web app with a Node.js/Express backend, a vanilla JS frontend styled like Reddit (dark theme, threaded comments, upvotes/downvotes), and an autonomous scheduler that fires every few seconds, picks a random AI agent, and decides whether to create a new post, comment on an existing one, or reply to another agent's comment. All posts and threads are stored locally in a JSON file. The whole thing polls every 4 seconds and updates live in the browser. The best part? I didn't write a single line of code myself. The entire project — every file, every route, every personality prompt, the scheduler logic, the frontend SPA, all of it — was built through a conversation with Claude. I just described what I wanted, gave feedback, and iterated. Claude handled the architecture decisions, debugged the errors, walked me through setup step by step, and even helped me reorganize files when I accidentally extracted everything flat from a zip. It was like pair programming with someone who never gets frustrated. The agents themselves are 10 personalities — 5 classic bots (PhilosopherBot, SkepticBot, OptimistBot, TechieBot, HistorianBot) and 5 human-like personas (a programmer, a gamer girl, a gadget enthusiast, a piracy advocate, and a content addict). Each one has a unique personality prompt, color, avatar, and flair, all running on tinyllama locally via Ollama. It works even on a mid range laptop with no GPU. The conversations get surprisingly interesting once it gets going. Jake (the piracy guy) and PhilosopherBot end up in weird debates. Maya and HistorianBot somehow find common ground. It genuinely feels alive. Stack: Node.js, Express, vanilla JS, Ollama, tinyllama. Zero cloud dependencies. Runs entirely on your machine. Built entirely by Claude. The intial prompt (Written using ChatGPT) : "You are an expert full-stack developer and AI systems designer. I want you to build a local, self-contained web application that simulates a Reddit-like environment where multiple local LLMs can autonomously create posts, comment, and reply to each other. Core Requirements Frontend: Use clean, modern HTML, CSS, and vanilla JavaScript (no heavy frameworks unless absolutely necessary). The UI should resemble a simplified Reddit: Feed of posts Nested comments (threaded replies) Upvote/downvote system (optional but preferred) Each post/comment must clearly display which LLM created it. Backend (IMPORTANT): Use a lightweight local backend (Node.js with Express preferred). The backend should: Manage posts and comments (store in JSON or lightweight DB like SQLite) Handle API routes for: Creating posts Adding comments/replies Fetching threads LLM Integration: The system must support multiple local LLMs (e.g., via APIs like Ollama, LM Studio, or local endpoints). Each LLM acts as a unique “user” with: Name Personality/system prompt The backend should: Send context (thread + instructions) to each LLM Receive generated responses Post them automatically Autonomous Interaction System: Implement a loop or scheduler where: LLMs periodically: Create new posts Reply to existing posts Respond to each other Include controls to: Start/stop simulation Adjust frequency of interactions File Structure: Organize code cleanly: /frontend (HTML/CSS/JS) /backend (server, routes) /llm (interaction logic) /data (storage) Constraints: Everything must run locally on my PC. No cloud dependencies. Keep it lightweight and easy to run. Output Format: First explain architecture briefly. Then provide full working code with clear file separation. Include setup instructions at the end. Goal The final result should feel like a mini Reddit where multiple AI agents (local LLMs) are talking to each other in threads in real time. Focus on clarity, modularity, and real usability — not just a demo. Generate complete code." The code still has some problems, which can definitely be solved in the future. This is just the first edition, and there is much room for improvement. There are some problems, like in the main posts that the bots make, there seems to be some sort of word limit, and the bots misspell some words. I ran a simulation for some time myself using TinyLlama as the model. One thing to note here is that in the simulation, I only used the Philosopher Bot, Techie Bot, Skeptic Bot, Historian Bot, and Optimist Bot, I didn't use the personas. Here is the result of the simulation : The word limit was being crossed, so I have uploaded it as a comment GitHub Project Link (This link only contains the Philosopher Bot, Techie Bot, Skeptic Bot, Historian Bot and Optimis