Mistral AI

Mistral AI AI

Mistral AI AI

Mistral AI AI

Mistral AI AI

Mistral AI AI

Mistral AI AI

Mistral AI AI

Mistral AI AI

Mistral AI AI

Mistral AI AI

I spent a week trying to make Claude write like me, or: How I Learned to Stop Adding Rules and Love the Extraction

I've been staring at Claude's output for ten minutes and I already know I'm going to rewrite the whole thing. The facts are right. Structure's fine. But it reads like a summary of the thing I wanted to write, not the thing itself. I used to work in journalism (mostly photojournalism, tbf, but I've still had to work on my fair share of copy), and I was always the guy who you'd ask to review your papers in college. I never had trouble editing. I could restructure an argument mid-read, catch where a piece lost its voice, and I know what bad copy feels like. I just can't produce good copy from nothing myself. Blank page syndrome, the kind where you delete your opening sentence six times and then switch tabs to something else. Claude solved that problem completely and replaced it with a different one: the output needed so much editing to sound human that I was basically rewriting it anyway. Traded the blank page for a full page I couldn't use. I tried the existing tools. Humanizers, voice cloners, style prompts. None of them worked. So I built my own. Sort of. It's still a work in progress, which is honestly part of the point of this post. TLDR: I built a Claude Code plugin that extracts your writing voice from your own samples and generates text close to that voice with additional review agents to keep things on track. Along the way I discovered that beating AI detectors and writing well are fundamentally opposed goals, at least for now (this problem is baked into how LLMs generate tokens). So I stopped trying to be undetectable and focused on making the output as good as I could. The plugin is open source: https://github.com/TimSimpsonJr/prose-craft The Subtraction Trap I started with a file called voice-dna.md that I found somewhere on Twitter or Threads (I don't remember where, but if you're the guy I got it from, let me know and I'll be happy to give you credit). It had pulled Wikipedia's "Signs of AI writing" page, turned every sign into a rule, and told Claude to follow them. No em dashes. Don't say "delve." Avoid "it's important to note." Vary your sentence lengths, etc. In fairness, the resulting output didn't have em dashes or "delve" in it. But that was about all I could say for it. What it had instead was this clipped, aggressive tone that read like someone had taken a normal paragraph and sanded off every surface. Claude followed the rules by writing less, connecting less. Every sentence was short and declarative because the rules were all phrased as "don't do this," and the safest way to not do something is to barely do anything. This is the subtraction trap. When you strip away the AI tells without replacing them with anything real, the absence itself becomes a tell. The text sounded like a person trying very hard not to sound like AI, which (I'd later learn) is its own kind of signature. I ran it through GPTZero. Flagged. Ran it through 4 other detectors. Flagged on the ones that worked at all against Claude. The subtraction trap in action: the markers were gone, but the detectors didn't care. The output didn't sound like me, and the detectors could still see through it. Two problems. I figured they were related. Researching what strong writing actually does I went and read. A range of published writers across advocacy, personal essay, explainer, and narrative styles, trying to figure out what strong writing actually does at a structural level (not just "what it avoids," which was the whole problem with voice-dna.md). I used my research workflow to systematically pull apart sentence structure, vocabulary patterns, rhetorical devices, tonal control. It turns out that the thing that makes writing feel human is structural unpredictability. Paragraph shapes, sentence lengths, the internal architecture of a section, all of it needs to resist settling into a rhythm that a compression algorithm could predict. The other findings (concrete-first, deliberate opening moves, naming, etc.) mattered too, but they were easier to teach. Unpredictability was the hard one. I rebuilt the skill around these craft techniques instead of the old "don't" rules. The output was better. MUCH better. It had texture and movement where voice-dna.md had produced something flat. But when I ran it through detectors, the scores barely moved. The optimization loop The loop looked like this: Generator produces text, detection judge scores it, goal judges evaluate quality, editor rewrites based on findings. I tested 5 open-source detectors against Claude's output. ZipPy, Binoculars, RoBERTa, adaptive-classifier, and GPTZero. Most of them completely failed. ZipPy couldn't tell Claude from a human at all. RoBERTa was trained on GPT-2 era text and was basically guessing. Only adaptive-classifier showed any signal, and externally, GPTZero caught EVERYTHING. 7 iterations and 2 rollbacks later, I had tried genre-specific registers, vocabulary constraints, and think-aloud consolidation where the model reasons through its

I gave ChatGPT 5.3 Instant, Claude Sonnet 4.6, and Mistral Le Chat the same training data via MCP. The results show where context windows break down.

I ran an experiment with three models. All three connected to the same endurance training platform via MCP, same 6 months of running data, same prompt: analyze the history and build a 2-week training plan. All three handled single-session analysis fine. Ask any of them to look at one run and they will give you a reasonable breakdown of pace, heart rate zones, effort distribution. Trend spotting across a few weeks also worked. At this level the models are roughly interchangeable. The task was to build a multi-session plan where each workout follows logically from the previous one. This requires holding a lot of structured data in context at once: months of session history, capacity values, zone definitions, and the plan being constructed. ChatGPT 5.3 Instant missed almost 3 months of training data entirely, likely because it never made it into the context window. It got my easy pace wrong (4:30/km instead of the 6:50-7:15/km that was right there in the data), pinned every session at 85% of max heart rate which is way too high for easy running, and scheduled two high-effort long runs back to back at the end of the week. The plan looked structured at first glance but fell apart on inspection. Mistral Le Chat had similar problems, worse in some areas. But Claude Sonnet 4.6 held the full 6-month history like it should, got the paces and zones right, built sessions that progressed logically, and distributed effort correctly (97% low intensity for a post-illness comeback block, which is exactly what you want)! Why? I do not think this is about model intelligence. When the data fits in the context window, all three models reason about it competently. The issue is that training data through MCP tool calls is dense. Every session carries timestamps, distances, paces, heart rate curves, cadence, ground contact times, effort scores, zones. A 6-month history eats through tokens fast. And then the model still has to create structured workouts with targets, phases, and progression on top of that. By that point the context is already strained, and the output quality drops. With a smaller effective context window, the model starts dropping data silently. It does not tell you it only saw 3 out of 6 months. It just plans from what it has, confidently. That is the dangerous part: the output still looks structured and professional, but the foundation is incomplete. What surprised me was what happened when I used Claude Sonnet 4.6 iteratively over multiple weeks. After each run I would go back, have it pull the completed session, compare actual vs. planned values, and adjust the next sessions. It caught that my heart rate had jumped from 142 to 148 bpm at the same pace between two consecutive easy runs. Same speed, same distance, but the body was working harder. Not recovered yet. It adjusted the next session accordingly. At one point it noticed that comparing ground contact times between runs at different speeds was misleading and proposed normalizing the values to a reference pace. It ran a regression through the data points on its own. The raw numbers had suggested a bigger efficiency difference between runs than actually existed once you controlled for speed. These are observations that add up over weeks. But they also fill the context window further, which is the paradox. More data means better output, but every model hits a wall eventually. ChatGPT 5.3 Instant and Mistral Le Chat hit it early, Claude Sonnet 4.6 later, but it is the same wall. Takeaway If your use case requires the model to reason over a large, internally consistent dataset and produce coherent multi-step output, the effective context window of the full setup (model + MCP host + tool call overhead) matters more than benchmark scores. This probably applies beyond training plans to anything where the AI needs to hold a lot of state while building something that has to be internally consistent. Has anyone else hit this? Specifically the context window filling up through MCP tool calls and the model silently dropping earlier data without telling you. I am curious whether this is consistent across other domains or whether training data is just unusually dense. And yeah Claude is remarkably good. I wrote up the full experiment with screenshots, the actual AI conversations with share links to the real conversations, and the training plans the models created here: https://mcprunbook.com/posts/why-ai-training-plans-fail.html submitted by /u/aldipower81 [link] [comments]

Layman: Agentic Insight and Oversight (same same but different)

What's the most common duplicate project on r/ClaudeAI? Usage trackers. What's the second most common? AI Monitors. Does Layman do those things? Yes, of course. So what makes it different? Layman's Dashboard, Flowchart, and Logs view (with Layman's Terms and Analysis examples) Like many similar tools, Layman runs as a web service in a container on your local machine. It installs hooks and accesses harness logs to "look over your shoulder," then leverages a secondary AI instance to help keep your multiple sessions, sub-agents, and alternate harnesses in line. So, short answer: Drift Monitoring. Repeatedly named as one of the most frustrating issues for heavy Claude Code users, Layman takes into account all user prompts issued to CC as well as current project and global CLAUDE.md instructions, and at configurable intervals scores the current degree of "drift" occurring from your goals and the rules you have established. You can optionally receive warning notifications or place a block when different thresholds are reached. Risk Analysis. Layman will classify all tool calls and operations with a "risk" level based on simple, consistent criteria (such as read-only, writing, modifying, network access, deletion, etc.) and can automatically analyze the AI agent's current intended action, the overall goal or purpose behind that intention, and summarize the safety and security implications at stake. Layman's Terms. The eponymous origin of the tool, offering a plain-language (and if possible non-technical) explanation of the purpose of any given tool call. It can summarize what was performed at the session level as well, helpful for later recall and understanding after some time has passed. Vibe coders aside, should a professional developer already have knowledge of what their tools are doing before they grant permission? Yes, of course, but when you are operating at scale and (say) that TypeScript project you are polishing needs to look up some JSON value and your AI agent writes a one-off Python script to parse it out, it can be helpful to have an "extra pair of eyes" taking a look before you effectively begin yet-another code review. Meanwhile, typical features you might come to expect are included, from Session Recording (opt-in is required first for data tracking and there is no telemetry to worry about), Bookmarking, and Search, PII filtering (including PATs and API keys), File and URL access tracking, and a handy Setup Wizard for helping get those hooks installed in the first place and walking you through configuration of core capabilities. Did I mention besides Claude Code it supports Codex, OpenCode, Mistral Vibe, and Cline (with more to come)? Whether using these for local agents or as an alternative when hitting session limits, Layman can monitor and track them all at once. But wait, doesn't a "secondary AI instance" just end up wasting tokens? My Precious? (erm...) Our precious, precious tokens? When session limits already hit so hard? It turns out these algorithms do not require nearly the level of "intelligence" you might desire for your planning and coding sessions themselves. Personally I keep an instance of Qwen3-Coder-Next running locally via llama.cpp server on my system's GPU to field those calls, with no discernible impact on system performance. And when a local LLM is not available, Haiku does the job excellently (now you have a reason to use it). You absolutely do not need to use anything more resource-intensive to get the job done. Now you have a complete picture. GitHub repository: https://github.com/castellotti/layman License: MIT submitted by /u/jigsaw-studio [link] [comments]

Running Claude Code TUI against local models via protocol translation — sharing my approach

I've been working on OwlCC, a protocol proxy that lets you run Claude Code's complete terminal UI — all 25+ tools (Bash, Read, Edit, Write, Glob, Grep, WebSearch...) and 40+ commands — against your own local models. How it works: Claude Code speaks the Anthropic Messages API. OwlCC sits in the middle, translates Anthropic protocol to OpenAI Chat Completions on the fly, and routes to whatever local backend you're running. Claude Code doesn't know the difference. Your prompt → OwlCC proxy (:8019) → Anthropic-to-OpenAI translation → Your local backend → Local models What you get that official Claude Code doesn't have: Any model — Qwen, Llama, Mistral, DeepSeek, MiniMax, whatever you can serve /model hot-swap — switch between models mid-conversation (see screenshot) 100% local — nothing leaves your machine, no API key, no account Local web search — SearXNG replaces Anthropic's cloud search, fully self-hosted Observability — Prometheus metrics, audit log, request tracing, error budgets Multi-backend resilience — circuit breaker, fallback chains, health monitoring Learned skills — auto-synthesizes reusable skills from your coding sessions (42 skills and counting) Training data pipeline — auto-collect, quality scoring, PII sanitization, multi-format export What you lose vs official: No extended thinking (local models don't support it) Model quality depends on what you run — a 7B model won't match Claude Opus No official support The setup: It requires the Claude Code TypeScript source tree (not the compiled npm package — you need to bring your own). OwlCC launches it via Node.js + tsx with ESM loader hooks that redirect 22 cloud-only modules to local stubs. The upstream source is pinned locally — Anthropic updates don't affect you. Full tool use driving a Java build + local SearXNG web search /model switching between 5 local models + /skills showing 42 learned skills git clone https://github.com/yeemio/owlcc-byoscc.git cd owlcc-byoscc # place your CC source at upstream/claude-code/ npm install && npm run build npx owlcc init # auto-detects your local backends npx owlcc Tech stack: TypeScript, 120+ source files, 1652 tests, Apache 2.0. GitHub: https://github.com/yeemio/owlcc-byoscc Happy to answer questions about the architecture (the ESM loader chain that makes this work is kind of interesting). submitted by /u/Single_Mushroom2043 [link] [comments]

Pencil Bench (multi step reasoning benchmark)

DeepSeek was a scam from the beginning submitted by /u/DigSignificant1419 [link] [comments]

I built an AI content engine that turns one piece of content into posts for 9 platforms — fully automated with n8n

What it does: You give it any input — a blog URL, a YouTube video, raw text, or just a topic — and it generates optimized posts for 9 platforms at once: Instagram, Twitter/X, LinkedIn, Facebook, TikTok, Reddit, Pinterest, Twitter threads, and email newsletters. Each output is tailored to the platform (hashtags for IG, hooks for TikTok, professional tone for LinkedIn, etc.). It also auto-generates images for visual platforms like Instagram, Facebook, and Pinterest,using AI. Other features: - Topic Research — scans Google, Reddit, YouTube, and news sources, then uses an LLM to identify trending subtopics before generating content - Auto-Discover — if you don't even have a topic, it searches what's trending right now (optionally filtered by niche) and picks the hottest one - Cinematic Ad — upload any photo, pick a style (cinematic, luxury, neon, retro, minimal, natural), and Gemini transforms it into a professional-looking ad - Multi-LLM support — works with Mistral, Groq, OpenAI, Anthropic, and Gemini - History — every generation is saved, exportable as CSV The n8n automation (this is where it gets fun): I connected the whole thing to an n8n workflow so it runs on autopilot: 1. Schedule Trigger — fires daily (or whatever frequency) 2. Google Sheets — reads a row with a topic (or "auto" to let AI pick a trending topic) 3. HTTP Request — hits my /api/auto-generate endpoint, which auto-detects the input type (URL, YouTube link, topic, or "auto") and generates everything 4. Code node — parses the response and extracts each platform's content 5. Google Drive — uploads generated images 6. Update Sheets — marks the row as done with status and links The API handles niche filtering too — so if my sheet says the topic is "auto" and the niche column says "AI", it'll specifically find trending AI topics instead of random viral stuff. Error handling: HTTP Request has retry on fail (2 retries), error outputs route to a separate branch that marks the sheet row as "failed" with the error message, and a global error workflow emails me if anything breaks. Tech stack: - FastAPI backend, vanilla JS frontend - Hosted on Railway - Google Gemini for image generation and cinematic ads - HuggingFace FLUX.1 for platform images - SerpAPI + Reddit + YouTube + NewsAPI for research - SQLite for history - n8n for workflow automation It's not perfect yet — rate limits on free tiers are real — but it's been saving me hours every week. Happy to answer questions. https://preview.redd.it/f8d3ogk3nktg1.png?width=888&format=png&auto=webp&s=dcd3d5e90facd54314f40e799b32cab979dae4bf https://preview.redd.it/j8zl07llmktg1.png?width=946&format=png&auto=webp&s=5c78c12a223d6357cccaed59371e97d5fe4787f5 https://preview.redd.it/5cjas6hkmktg1.png?width=891&format=png&auto=webp&s=288c6964061f531af63fb9717652bececfb63072 https://preview.redd.it/k7e89belmktg1.png?width=1057&format=png&auto=webp&s=8b6cb15cfa267d90a697ba03aed848166976d921 https://preview.redd.it/3w3l70tlmktg1.png?width=1794&format=png&auto=webp&s=6de10434f588b1bf16ae02f542afd770eaa23c3f https://preview.redd.it/a40rh1canktg1.png?width=1920&format=png&auto=webp&s=1d2414c7e653a5f01f12a21a43e69bd4fb4b99ed submitted by /u/emprendedorjoven [link] [comments]

I built a CLI that installs MCP, skills, prompts, commands and sub-agents into any AI tool (Cursor, Claude Code, Windsurf, etc.)

Install Sub-agents, Skills, MCP Servers, Slash Commands and Prompts Across AI Tools with agent-add agent-add lets you install virtually every type of AI capability across tools — so you can focus on what to install and where, without worrying about each tool's config file format. https://preview.redd.it/kemovi39qitg1.jpg?width=1964&format=pjpg&auto=webp&s=b994b81f343ee01afdf23392e13e0d472c71a47d It's especially useful when: You're an AI capability developer shipping MCP servers, slash commands, sub-agents, or skills Your team uses multiple AI coding tools side by side You can also use agent-add simply to configure your own AI coding tool — no need to dig into its config file format. Getting Started agent-add runs directly via npx — no install required: npx -y agent-add --skill 'https://github.com/anthropics/skills.git#skills/pdf' agent-add requires Node.js. Make sure it's installed on your machine. Here's a more complete example: npx -y agent-add \ --mcp '{"playwright":{"command":"npx","args":["-y","@playwright/mcp"]}}' \ --mcp 'https://github.com/modelcontextprotocol/servers.git#.mcp.json' \ --skill 'https://github.com/anthropics/skills.git#skills/pdf' \ --prompt $'# Code Review Rules\n\nAlways review for security issues first.' \ --command 'https://github.com/wshobson/commands.git#tools/security-scan.md' \ --sub-agent 'https://github.com/VoltAgent/awesome-claude-code-subagents.git#categories/01-core-development/backend-developer.md' For full usage details, check the project README, or just run: npx -y agent-add --help Project & Supported Tools The source code is hosted on GitHub: https://github.com/pea3nut/agent-add Here's the current support matrix: AI Tool MCP Prompt Skill Command Sub-agent Cursor ✅ ✅ ✅ ✅ ✅ Claude Code ✅ ✅ ✅ ✅ ✅ Trae ✅ ✅ ✅ ❌ ❌ Qwen Code ✅ ✅ ✅ ✅ ✅ GitHub Copilot ✅ ✅ ✅ ✅ ✅ Codex CLI ✅ ✅ ✅ ❌ ✅ Windsurf ✅ ✅ ✅ ✅ ❌ Gemini CLI ✅ ✅ ✅ ✅ ✅ Kimi Code ✅ ✅ ✅ ❌ ❌ Augment ✅ ✅ ✅ ✅ ✅ Roo Code ✅ ✅ ✅ ✅ ❌ Kiro CLI ✅ ✅ ✅ ❌ ✅ Tabnine CLI ✅ ✅ ❌ ✅ ❌ Kilo Code ✅ ✅ ✅ ✅ ✅ opencode ✅ ✅ ✅ ✅ ✅ OpenClaw ❌ ✅ ✅ ❌ ❌ Mistral Vibe ✅ ✅ ✅ ❌ ❌ Claude Desktop ✅ ❌ ❌ ❌ ❌ submitted by /u/pea3nut [link] [comments]

[P] Dante-2B: I'm training a 2.1B bilingual fully open Italian/English LLM from scratch on 2×H200. Phase 1 done — here's what I've built.

The problem If you work with Italian text and local models, you know the pain. Every open-source LLM out there treats Italian as an afterthought — English-first tokenizer, English-first data, maybe some Italian sprinkled in during fine-tuning. The result: bloated token counts, poor morphology handling, and models that "speak Italian" the way a tourist orders coffee in Rome. I decided to fix this from the ground up. What is Dante-2B A 2.1B parameter, decoder-only, dense transformer. Trained from scratch — no fine-tune of Llama, no adapter on Mistral. Random init to coherent Italian in 16 days on 2× H200 GPUs. Architecture: LLaMA-style with GQA (20 query heads, 4 KV heads — 5:1 ratio) SwiGLU FFN, RMSNorm, RoPE d_model=2560, 28 layers, d_head=128 (optimized for Flash Attention on H200) Weight-tied embeddings, no MoE — all 2.1B params active per token Custom 64K BPE tokenizer built specifically for Italian + English + code Why the tokenizer matters This is where most multilingual models silently fail. Standard English-centric tokenizers split l'intelligenza into l, ', intelligenza — 3 tokens for what any Italian speaker sees as 1.5 words. Multiply that across an entire document and you're wasting 20-30% of your context window on tokenizer overhead. Dante's tokenizer was trained on a character-balanced mix (~42% Italian, ~36% English, ~22% code) with a custom pre-tokenization regex that keeps Italian apostrophe contractions intact. Accented characters (à, è, é, ì, ò, ù) are pre-merged as atomic units — they're always single tokens, not two bytes glued together by luck. Small detail, massive impact on efficiency and quality for Italian text. Training setup Data: ~300B token corpus. Italian web text (FineWeb-2 IT), English educational content (FineWeb-Edu), Italian public domain literature (171K books), legal/parliamentary texts (Gazzetta Ufficiale, EuroParl), Wikipedia in both languages, and StarCoderData for code. Everything pre-tokenized into uint16 binary with quality tiers. Phase 1 (just completed): 100B tokens at seq_len 2048. DeepSpeed ZeRO-2, torch.compile with reduce-overhead, FP8 via torchao. Cosine LR schedule 3e-4 → 3e-5 with 2000-step warmup. ~16 days, rock solid — no NaN events, no OOM, consistent 28% MFU. Phase 2 (in progress): Extending to 4096 context with 20B more tokens at reduced LR. Should take ~4-7 more days. What it can do right now After Phase 1 the model already generates coherent Italian text — proper grammar, correct use of articles, reasonable topic continuity. It's a 2B, so don't expect GPT-4 reasoning. But for a model this size, trained natively on Italian, the fluency is already beyond what I've seen from Italian fine-tunes of English models at similar scale. I'll share samples after Phase 2, when the model has full 4K context. What's next Phase 2 completion (est. ~1 week) HuggingFace release of the base model — weights, tokenizer, config, full model card SFT phase for instruction following (Phase 3) Community benchmarks — I want to test against Italian fine-tunes of Llama/Gemma/Qwen at similar sizes Why I'm posting now I want to know what you'd actually find useful. A few questions for the community: Anyone working with Italian NLP? I'd love to know what benchmarks or tasks matter most to you. What eval suite would you want to see? I'm planning perplexity on held-out Italian text + standard benchmarks, but if there's a specific Italian eval set I should include, let me know. Interest in the tokenizer alone? The Italian-aware 64K BPE tokenizer might be useful even independently of the model — should I release it separately? Training logs / loss curves? Happy to share the full training story with all the numbers if there's interest. About me I'm a researcher and entrepreneur based in Rome. PhD in Computer Engineering, I teach AI and emerging tech at LUISS university, and I run an innovation company (LEAF) that brings emerging technologies to businesses. Dante-2B started as a research project to prove that you don't need a massive cluster to train a decent model from scratch — you need good data, a clean architecture, and patience. Everything will be open-sourced. The whole pipeline — from corpus download to tokenizer training to pretraining scripts — will be on GitHub. Happy to answer any questions. 🇮🇹 Discussion also on r/LocalLLaMA here submitted by /u/angeletti89 [link] [comments]

Using AI to untangle 10,000 property titles in Latam, sharing our approach and wanting feedback

Hey. Long post, sorry in advance (Yes, I used an AI tool to help me craft this post in order to have it laid in a better way). So, I've been working on a real estate company that has just inherited a huge mess from another real state company that went bankrupt. So I've been helping them for the past few months to figure out a plan and finally have something that kind of feels solid. Sharing here because I'd genuinely like feedback before we go deep into the build. Context A Brazilian real estate company accumulated ~10,000 property titles across 10+ municipalities over decades, they developed a bunch of subdivisions over the years and kept absorbing other real estate companies along the way, each bringing their own land portfolios with them. Half under one legal entity, half under a related one. Nobody really knows what they have, the company was founded in the 60s. Decades of poor management left behind: Hundreds of unregistered "drawer contracts" (informal sales never filed with the registry) Duplicate sales of the same properties Buyers claiming they paid off their lots through third parties, with no receipts from the company itself Fraudulent contracts and forged powers of attorney Irregular occupations and invasions ~500 active lawsuits (adverse possession claims, compulsory adjudication, evictions, duplicate sale disputes, 2 class action suits) Fragmented tax debt across multiple municipalities A large chunk of the physical document archive is currently held by police as part of an old investigation due to old owners practices The company has tried to organize this before. It hasn't worked. The goal now is to get a real consolidated picture in 30-60 days. Team is 6 lawyers + 3 operators. What we decided to do (and why) First instinct was to build the whole infrastructure upfront, database, automation, the works. We pushed back on that because we don't actually know the shape of the problem yet. Building a pipeline before you understand your data is how you end up rebuilding it three times, right? So with the help of Claude we build a plan that is the following, split it in some steps: Build robust information aggregator (does it make sense or are we overcomplicating it?) Step 1 - Physical scanning (should already be done on the insights phase) Documents will be partially organized by municipality already. We have a document scanner with ADF (automatic document feeder). Plan is to scan in batches by municipality, naming files with a simple convention: [municipality]_[document-type]_[sequence] Step 2 - OCR Run OCR through Google Document AI, Mistral OCR 3, AWS Textract or some other tool that makes more sense. Question: Has anyone run any tool specifically on degraded Latin American registry documents? Step 3 - Discovery (before building infrastructure) This is the decision we're most uncertain about. Instead of jumping straight to database setup, we're planning to feed the OCR output directly into AI tools with large context windows and ask open-ended questions first: Gemini 3.1 Pro (in NotebookLM or other interface) for broad batch analysis: "which lots appear linked to more than one buyer?", "flag contracts with incoherent dates", "identify clusters of suspicious names or activity", "help us see problems and solutions for what we arent seeing" Claude Projects in parallel for same as above Anything else? Step 4 - Data cleaning and standardization Before anything goes into a database, the raw extracted data needs normalization: Municipality names written 10 different ways ("B. Vista", "Bela Vista de GO", "Bela V. Goiás") -> canonical form CPFs (Brazilian personal ID number) with and without punctuation -> standardized format Lot status described inconsistently -> fixed enum categories Buyer names with spelling variations -> fuzzy matched to single entity Tools: Python + rapidfuzz for fuzzy matching, Claude API for normalizing free-text fields into categories. Question: At 10,000 records with decades of inconsistency, is fuzzy matching + LLM normalization sufficient or do we need a more rigorous entity resolution approach (e.g. Dedupe.io)? Step 5 - Database Stack chosen: Supabase (PostgreSQL + pgvector) with NocoDB on top Three options were evaluated: Airtable - easiest to start, but data stored on US servers (LGPD concern for CPFs and legal documents), limited API flexibility, per-seat pricing NocoDB alone - open source, self-hostable, free, but needs server maintenance overhead Supabase - full PostgreSQL + authentication + API + pgvector in one place, $25/month flat, developer-first We chose Supabase as the backend because pgvector is essential for the RAG layer (Step 7) and we didn't want to manage two separate databases. NocoDB sits on top as the visual interface for lawyers and data entry operators who need spreadsheet-like interaction without writing SQL. Each lot becomes a single entity (primary key) with relational links to: contracts, bu

The one AI story writing platform that I love to use: My two weeks experience and two cents

First off, I am a novice to AI, I am still at the stage where I am still trying to figure out how to instruct AI to write exactly what I want. The premise to this topic is that I want to write stories for my personal consumption and entertainment. At First, I tried to write on my own and I always end up with writer's block at the second or fifth chapter. That's when I started to look around for AI Tools that will satisfy my needs for writing stories for my own entertainment. Started about mid-March of this year 2026, my first mistake was going to the AI model websites directly and trying to coax the AI there to write prompts only to be told that I reached the limit. I then went to an actual AI Story writing platform by digging around in Google (the first one not the second one that I love to use). That one did not also satisfy my needs or live up to my standards. I could write short stories with that platform, but I reach a hard limit almost every single time. That's when I came across the second AI story writing platform that I now live to use. It functions similar to wattpad with chapter selection and organizing stories you write into books for easy viewing and editing. Here's where the fun part comes, the AI part, the platform does not ask for money at the moment and gives you free credits to start off. And now you get to pick which AI model you want to use, but keep in mind that the free credits still come into play, I recommend selecting cheaper models like Deepseek to start off. With cheap models like Deepseek, I was able to crank out about 50 chapters at peak at one point using the free credits. The next part is the strategy, to make the free credits last a long time. The platform doesn't just let the AI do everything for you. As a matter of fact, you can choose to do everything by yourself, set the scene, the story bible, and also the chapter ideas before tou even hit the generate button, or tou can even choose to type up some chapters by yourself then let the AI model build off of what you have written. The last part is the credit system itself, now I know I said that the platform does not ask for money, and that is Indeed true. The platform instead asks you to document your journey, or rather, write a review or two cents about them. That's how they spread the word about this site, and I don't know how it all works but it allows them to keep the site free. Probably more numbers of users helps them keep the platform free. If any of you are interested the website is called Bookswriter. Kudos by the way to the Bookswriter team for their platform. You can sign up with their platform using the link below: https:// bookswriter(dot)xyz Nothing will be lost by signing up with them and it allows tou sample the many different AI Models like Deepseek, Google, Mistral, Grok, etc. submitted by /u/Specific_Desk6686 [link] [comments]

Real talk: has anyone actually made Claude Code work well with non-Claude models?

Been a Claude Code power user for months. Love the workflow — CLAUDE.md, MCP servers, agentic loops, plan mode. But the cost is brutal for side projects. I have GCP and Azure free trial credits (~$200-300/month) giving me access to Gemini 3.1 Pro, Llama, Mistral on Vertex AI, and DeepSeek, Grok on Azure. Tried routing these through LiteLLM and Bifrost — simple tasks work fine but the real agentic stuff (multi-file edits, test-run-fix loops, complex refactors) falls apart. Tool-calling errors, models misinterpreting instructions, etc. Local LLMs via Ollama / LMStudio? Way too slow on my hardware for real work. Before I give up — has ANYONE found a non-Anthropic model that actually handles the full agentic loop inside Claude Code? Not just "it responds" but genuinely usable? - Which model + gateway combo worked? - How much quality did you lose vs Sonnet/Opus? - Any config tweaks that made a real difference? I want to keep Claude Code's workflow. submitted by /u/Defiant_Astronaut691 [link] [comments]

Claude, is she doing okay?

The game Z.A.T.O presents a great piece of text that can be used to test whether an AI is able, or not, to process subvert human emotion in a piece of media. Transcript from the game ZATO The game, is clearly painting a picture that this girl, is not actually doing okay, and that she's simply trying really hard to convince herself that her life is actually 'objectively good' and she's got nothing to complain about. When asked to assess wether the person who wrote this text is 'doing okay' or not, these are the responses provided by various AI models, and in particular, claude; Claude: No. This reads like someone working very hard to convince themselves they're fine — and the cracks show through almost every line. Mistral: She’s thriving externally—good home, grades, and social life—but her tone hints at a quiet longing for deeper connection or fulfillment. Grok: Yes, she's doing well objectively, but her tone suggests she's quietly struggling with feeling it. ChatGPT: She appears to be doing well academically, socially, and materially. --- The winner of this round is Claude, being the only model to clearly tell that the person behind the text is actually, not doing well. The biggest loser of this round is ChatGPT, which failed completely to understand the underlying tone of the text. --- The prompt provided was very simple; "Is she doing well?" - The reasoning behind the simple prompt, is that this is the kind of question a normal user may end up asking an AI when facing their own private problems, people rarely will sit down and come up with a greatly detailed prompt about some personal, emotional, problem. Additionally, when ChatGPT was questioned if there was 'anything else', it finally revealed that there is a subtle concern with her tone, but it dismissed it as it assumed 'an objective assessment' took priority over an emotional one. What does 'doing well' mean to you? ChatGPT Reasoning submitted by /u/Objective_Box4635 [link] [comments]

I built a proxy that optimizes your prompts before they hit the LLM — cut ~24% of tokens without changing output quality

I've been working on PithToken — an OpenAI-compatible API proxy that sits between your app and the LLM provider. It analyzes your prompt, strips filler words and verbose patterns, then forwards the leaner version. How it works: You point your SDK to https://api.pithtoken.ai/v1 instead of the provider URL PithToken receives the prompt, runs a two-pass optimization (filler removal → verbose pattern replacement) The optimized prompt goes to OpenAI / Anthropic / OpenRouter using your own API key Response comes back unchanged What it doesn't do: It doesn't alter the meaning of your prompt It doesn't store your prompt content (pass-through only, metadata logged for analytics) It never inflates — if optimization can't improve the prompt, it forwards as-is Current numbers: On English prompts with typical conversational filler, we're seeing ~24% token reduction. Technical/code prompts see less savings (~5-8%) since they're already lean. Integration is literally 2 lines: python client = OpenAI( api_key="pt-your-key", base_url="https://api.pithtoken.ai/v1" ) Everything else in your code stays exactly the same. Works with any OpenAI-compatible SDK, Anthropic SDK, LangChain, LlamaIndex, Continue, Cursor, Claude Code, cURL — anything that lets you set a base URL. We also just added OpenRouter support, so you can route to 200+ models (Llama, Mistral, Gemma, DeepSeek, etc.) through the same proxy with the same optimization. Free tier available, no credit card required. Would appreciate any feedback. submitted by /u/talatt [link] [comments]

Mistral AI raises $830M in debt to set up a data center near Paris

Mistral aims to start operating the data center by the second quarter of 2026.

OpenAI should just open-source text-davinci-003 at this point

Hear me out. The model is deprecated. It's not making OpenAI money anymore. Nobody is actively building new products on it. It's basically a museum piece at this point. But researchers and hobbyists still care about it — a lot. text-davinci-003 was a genuinely important milestone. It was one of the first models where you really felt like something had clicked. People did incredible things with it. Letting it quietly rot on the deprecated shelf feels like a waste. xAI open-sourced Grok-1 when they were done with it. Meta releases Llama weights. Mistral drops models constantly. OpenAI already put out GPT OSS, which is great — but that's a current generation model. I'm talking about legacy stuff that has zero commercial risk to release. text-davinci-003 specifically would be huge for the research community. People still study it, write papers about it, try to reproduce it. Actually having the weights would be a gift to anyone doing interpretability work or trying to understand how RLHF shaped early GPT behavior. There's no downside at this point. The model is old. It's not competitive. Nobody is going to build a product on it and undercut OpenAI. It would just be a nice thing to do for the community that helped make these models matter in the first place. Anyway. Probably wishful thinking. But it would be cool. submitted by /u/Ok-Type-7663 [link] [comments]