https://devmystify.com Latest updates and insights from Devmystify en https://devmystify.com/blog/how-to-migrate-a-rails-app-from-heroku-to-digitalocean-app-platform Wed, 04 Mar 2026 07:56:01 GMT **Heads up:** After adding the database, DO will show an environment variable reference like `${your-db-name.DATABASE_URL}`. This looks like it should work automatically, but in practice, you’ll want to replace it with the actual connection string so Rails and Sidekiq receive a proper `DATABASE_URL`. We'll do that in the next step. > 3. **Add a Managed Valkey Instance** Add a second database and choose **Valkey,** DigitalOcean's Redis-compatible service. Your app and Sidekiq won't notice the difference.   4. **Set Environment Variables** This is the step that trips people up. Go to **Settings → Environment Variables**. You'll see `DATABASE_URL` and `REDIS_URL` (If you set one) set to reference values like `${your-db.DATABASE_URL}`. Replace both with the actual connection strings. To get the connection strings: - **PostgreSQL**: Go to your database → **Connection Details** → copy the **Connection String** - **Valkey**: Same thing, go to your Valkey instance → **Connection Details** → copy the connection string  Then add the rest of your environment variables from Heroku (`RAILS_MASTER_KEY`, any API keys, etc.).  5. **Restore Your Database** Before you deploy, restore your data. If you deploy first, your app will 500 on every request until the database is ready. Run this from your local machine using the connection details from your new PostgreSQL database: ```bash PGPASSWORD=your_password pg_restore \\ -U doadmin \\ -h your-db-host.db.ondigitalocean.com \\ -p 25060 \\ -d defaultdb \\ latest.dump ```  If you're starting fresh with no existing data, skip this and just run migrations after deploying instead. 6. **Deploy** Deploy your app. Once it's live, if you skipped the restore above, open the web console and run: ```bash rails db:migrate ```  7. **Add Sidekiq as a Worker Component** Sidekiq needs to run as a separate component so it has its own process and can be scaled or restarted independently from your web server. In DO App Platform, go to your app and create a new worker component: - **Resource type**: Worker - **Run command**: `bundle exec sidekiq` - **Environment variables**: Make sure `DATABASE_URL` and `REDIS_URL` are set here too. The worker needs both   Deploy the worker. Check the runtime logs, you should see Sidekiq boot up and connect to Valkey.  > **Note:** Running a separate worker component means paying for an additional instance. For low-traffic apps, you can start without it and add the worker only when you have actual background jobs that need processing. > 8. **Recreate Your CRON Jobs** DigitalOcean App Platform handles scheduled tasks as Job components, configured the same way as the worker above but with a schedule attached. Follow the official guide here: https://docs.digitalocean.com/products/app-platform/how-to/manage-jobs/ 9. **Point Your Domain to DigitalOcean**  Once your app is deployed, you can connect your custom domain. In App Platform, go to **Settings → Domains** and click **Add domain**. DigitalOcean will show you the DNS record you need to configure. Add that record at your DNS provider (or inside DigitalOcean DNS if you’re using it). After DNS propagates, [App Platform will automatically provision SSL for your domain](https://docs.digitalocean.com/support/how-do-i-generate-my-apps-ssl-certificate/). If you want the full step-by-step walkthrough, DigitalOcean has an official guide [here](https://docs.digitalocean.com/products/app-platform/how-to/manage-domains/). ## You're Live  Once everything is running, confirm traffic is flowing to DigitalOcean and monitor the app for any unexpected issues. You can run both environments in parallel for a day to be safe. When you're confident everything is stable, remove the Heroku app. Heroku isn't going away tomorrow, but it's no longer moving forward either. DigitalOcean App Platform gives you the same push-to-deploy simplicity with a platform that's still actively growing. [Get started on DigitalOcean with $200 credit](https://www.dpbolvw.net/click-101543071-17246817) today. ]]> https://devmystify.com/blog/the-clawdbot-craze Wed, 25 Feb 2026 10:43:40 GMT https://devmystify.com/blog/the-developer-identity-crisis-when-ai-split-programmers-into-two-tribes Wed, 11 Feb 2026 10:43:00 GMT 60%): - **Generate then Ask**: Generated code, then asked follow-up questions to understand it - **Hybrid Queries**: Asked for both code *and* explanations - **Conceptual Questions**: Used AI like a tutor. Asking "Why does this work?" not "Write this for me". Low scorers used AI as a **generator**. High scorers used AI as a **tutor**. ### The Middle Path: Active Learning You *can* use AI without losing skills. But you have to be intentional: 1. **Try solving it yourself first.** That struggle is where learning happens. 2. **Use AI for research, not replacement.** Ask "How does this work?" not "Write this for me." 3. **Review generated code line by line.** Read it. Understand it. Modify it yourself. 4. **Ask AI to explain.** "Why did you write it this way?" is more valuable than "Write this." 5. **Maintain ownership.** You should explain every line in your codebase. This is **active learning**, using AI to accelerate your understanding, not replace it. --- ## What This Means in Practice ### Junior Developers The Anthropic study shows AI during skill acquisition is harmful. You're building your foundation. If AI does the thinking, you won't develop debugging and comprehension skills. Better approach: Code manually for 6-12 months. Use AI for explanations, not generation. Build muscle memory. Once you have a foundation, *then* leverage AI more. ### Senior Developers You already have deep understanding. You can use AI more freely because you spot when it's wrong. This is where Spec-Driven Development makes sense. You know what good code looks like. You can write detailed specs and review AI output effectively. But watch for skill decay. If you stop coding in a language, you get rusty. ### Managing Teams Code review becomes critical. If devs use AI heavily, reviews need to verify understanding, not just correctness. Consider different guidelines for juniors vs. seniors. Maybe juniors have limited AI until they demonstrate mastery. [Google's DORA research (2025)](https://dora.dev/research/2025/) describes AI as an amplifier. Adoption is widespread and productivity is up but AI magnifies whatever system it enters. Strong teams see gains in throughput and performance; weaker ones risk amplifying instability. --- ## The Real Answer Both camps have valid points. **Manual purists are right:** Blind AI delegation causes comprehension debt, reduces code quality, and destroys skill formation. **AI architects are right:** For experienced developers on the right problems, AI dramatically increases output. The Anthropic study reveals the truth: **how you use AI determines your outcome.** Use AI as a generator, something that does your thinking. You'll get faster short-term but weaker long-term. Comprehension debt compounds. Debugging skills atrophy. You become dependent on a tool that can't solve novel problems. Use AI as a tutor, something that accelerates your thinking. You learn faster *and* maintain deep understanding. You explore, explain, verify. But you stay in the driver's seat. ### What Actually Matters The future isn't about speed. It's about **deep understanding**. AI can't innovate. It pattern-matches. When you hit a truly novel problem like weird edge case, complex architecture, production performance bottleneck. AI won't save you. Understanding will. We're entering a world where writing code is easy. AI does it in seconds. The hard thing (the valuable thing) is understanding what the code should do. Why it works. When it's wrong. How it fits the larger system. That's the skill worth protecting. The question isn't "Should I use AI?" It's "How do I use AI without losing the ability to think?" The answer: Stay actively engaged. Keep thinking. Don't outsource your understanding. Use the tool. Don't let the tool use you.]]> https://devmystify.com/blog/when-ai-gets-too-helpful-understanding-rag Wed, 04 Feb 2026 11:06:40 GMT Security > Change Password. You will need to verify your identity via email." [Chunk from FAQ] "If you forgot your password, click 'Forgot Password' on the login screen. A reset link will be sent to your registered email." --- User question: "How do I reset my password?" Answer ONLY based on the documents above. If the answer isn't in the documents, say you don't have that information. ``` This is called **grounding**. You're literally grounding the AI's response in actual source material. No more guessing. No more hallucinations based on vague training data. ### Stage 4: Response Generation Finally, the LLM reads the augmented prompt and generates an answer. But this time, it's not pulling from its training data. It's pulling from the documents you gave it. The output might look like: > "To reset your password, go to Settings > Security > Change Password. If you've forgotten it, use the 'Forgot Password' option on the login screen, and a reset link will be sent to your email." > The AI synthesizes the information into natural language, but the facts come from your documents. Some systems even add **citations**, telling you exactly which document or page the answer came from. --- ## Why RAG Works Better Than Alternatives You might be thinking: "Can't I just copy-paste my documents into the prompt?" Technically, yes. But there are better and worse ways to give AI context. | Approach | How It Works | Pros | Cons | Best For | | --- | --- | --- | --- | --- | | **Fine-tuning** | Retrain the model on your data | Knowledge baked into model | Expensive, slow updates | Domain-specific language (legal, medical) | | **Prompt Stuffing** | Paste documents directly into prompt | Simple, no setup | Limited by context window | 1-2 short documents | | **RAG** | Dynamic retrieval + generation | Scales to millions of docs, easy updates | Requires Vector DB setup | Most real-world use cases | The key difference? **Fine-tuning** is like sending the AI to medical school, it learns how to speak and think like a doctor. **RAG** is like giving that doctor a specific patient's medical file, it provides the facts to apply those skills to. And unlike fine-tuning, when your documentation updates, you don't need to retrain anything. Just update the Vector Database, and the AI immediately has access to the new information. --- ## Real-World Use Cases RAG isn't theoretical. It's already powering AI systems you probably use. **Customer Support**: Companies like Intercom and Zendesk use RAG to build chatbots that answer questions by reading product manuals, FAQs, and troubleshooting guides. Instead of training a model on every possible question, they just point it at their documentation. **Enterprise Knowledge**: Tools like Notion AI and Slack's AI search use RAG to help employees find information buried in wikis, meeting notes, and internal policies. The AI doesn't memorize your company's handbook; it searches through it in real-time. **Education**: Platforms like Khan Academy's Khanmigo use RAG to answer student questions by referencing lecture materials and textbooks. The AI becomes a study assistant that actually knows what's in the course content. **Legal & Compliance**: Legal tech companies like [Harvey.ai](http://harvey.ai/) and Casetext use RAG to search through contracts, case law, and regulations. Lawyers can ask questions in plain English, and the system surfaces relevant legal precedents. The pattern is clear: **RAG works best when you have a lot of documents and need accurate, source-backed answers**. --- ## What You Actually Need to Build RAG If you're thinking about implementing RAG, the stack isn't complicated. You need four core components: **1. Vector Database** – Where your embedded chunks live (Pinecone, Weaviate, Chroma) **2. Embedding Model** – Converts text into vectors (OpenAI's `text-embedding-3`, or open-source like `sentence-transformers`) **3. LLM for Generation** – The brain that writes answers (GPT-4, Claude, Gemini, or open models like Llama) **4. Orchestration Layer** – Handles the pipeline (LangChain, LlamaIndex, or build your own) That's it. The exact choices depend on whether you want managed services or self-hosted, and whether you need to run everything on-premise. But the components stay the same. --- ## Common Pitfalls (And How to Avoid Them) RAG sounds simple, but the devil's in the details. Here are the mistakes people make: **Problem 1: Chunk Size Is Off** Too large, and the AI gets confused by irrelevant information. Too small, and it lacks context to answer properly. The sweet spot is usually **300-500 words per chunk**, with a bit of overlap so sentences don't get cut off mid-thought. **Problem 2: Retrieval Quality Sucks** You ask about "password reset," but the system pulls up chunks about "account deletion." This happens when: - The embedding model isn't good enough - Your chunks aren't semantically distinct **Solution**: Use **hybrid search** (combine keyword matching with semantic search) and add a **reranking step** where a second model filters the results before sending them to the LLM. **Problem 3: Hallucinations Still Happen** RAG reduces hallucinations, but it doesn't eliminate them. The AI might still connect dots that aren't there or misinterpret retrieved chunks. **Solution**: Aggressive prompt engineering. Say things like "Answer ONLY if the information is in the documents. If not, say 'I don't have that information.'" Better yet, force the model to **cite sources** so users can verify the answer themselves. --- ## When NOT to Use RAG RAG isn't a silver bullet. There are cases where it's overkill or just the wrong tool. **Skip RAG if:** - You have fewer than 10 documents → Just paste them into the prompt (prompt stuffing is fine here) - You need creative generation (writing fiction, ads) → RAG constrains creativity by forcing the AI to stick to source material - You're dealing with real-time data (stock prices, live sports scores) → Direct API calls are faster and more accurate RAG shines when you have **lots of static or slow-changing documents** that you need to reference accurately. If your use case doesn't fit that pattern, you might be better off with a simpler approach. --- ## The Future: RAG Is Just the Start RAG is the baseline today, but the technology is evolving fast. **Agentic RAG**: Instead of you deciding which documents to search, the AI decides. It can query multiple knowledge bases, APIs, and even the web, then synthesize everything into one answer. **Multimodal RAG**: Right now, most RAG systems work with text. But the next generation will handle images, videos, and audio. Imagine asking "Show me diagrams about X" and the AI retrieves relevant charts from your PDFs. **Graph RAG**: Instead of treating documents as isolated chunks, Graph RAG uses **knowledge graphs** to understand relationships. It knows that "John works at Company X" and "Company X makes Product Y," so when you ask about Product Y, it can pull in context about John too. The core idea stays the same: **give AI documents to read before it answers**. But how we do that is getting smarter. --- ## Getting Started If you want to try RAG yourself, here's the easiest path: 1. **Start with LangChain**: They have pre-built templates and Jupyter notebooks you can run in minutes 2. **Use Chroma for storage**: It's free, runs locally, and requires zero setup 3. **Test with 5-10 documents**: Don't start with your entire company wiki. Start small, see what works, then scale **Resources**: - LangChain Q&A Tutorial: https://python.langchain.com/docs/use_cases/question_answering/ - Chroma Getting Started: https://docs.trychroma.com/getting-started --- ## Conclusion RAG isn't complicated. It's just "let the AI read before it answers." But making it work well requires attention to detail: good chunking, smart retrieval, and careful prompt engineering. The payoff is worth it. Instead of an AI that guesses and hallucinates, you get one that references actual sources. Instead of a system that gets outdated the moment you deploy it, you get one that stays current as long as you update the documents. For most real-world use cases where accuracy matters, RAG is the right answer. The question isn't "Should I use RAG?" It's "How do I implement it well?"]]> https://devmystify.com/blog/equip-your-ai-with-skills Wed, 28 Jan 2026 07:23:53 GMT https://devmystify.com/blog/picking-the-right-ai-for-your-saas Wed, 21 Jan 2026 10:22:38 GMT Use only when errors have real consequences (legal, financial, safety). > > > Not a default choice. > --- ### **OpenAI GPT-5.2 Pro** **Best for** - Extremely complex reasoning - Large-context analysis - Tasks where maximum quality matters more than cost **Why** - Very strong reasoning - Large 400K context window - Highest output quality from OpenAI **Estimated cost** - ~$1,500–1,800/month > This model is intentionally expensive. > > > Use only for rare, critical workloads. > --- ### **Gemini 3 Pro** **Best for** - Long documents - Multimodal (text + images) - Large-context applications **Why** - 1M token context window - Good balance of quality and price - Strong at document-heavy workflows **Estimated cost** - ~$120–150/month > Best choice when context length matters more than raw reasoning quality. > --- ### Tier 2: Balanced Models (Best Value for Most Apps) ### **OpenAI GPT-5.2** **Best for** - General-purpose workloads - Mixed reasoning + creativity - Apps needing a large context window **Why** - Solid reasoning - 400K context - Works well across many task types **Estimated cost** - ~$140–160/month > Often more expensive than Gemini 3 Flash for similar workloads but one of the default safe choices for many real-world products. > --- ### **Claude Sonnet 4.5** **Best for** - Production apps - Coding tools - General-purpose SaaS features **Why** - Excellent balance of quality and cost - Very strong at coding and refactoring - Stable output **Estimated cost** - ~$160–180/month - ~$80–100/month with Batch API > This is one of the “default safe choices” for many real-world products. > --- ### **Gemini 3 Flash** **Best for** - High-volume chatbots - Simple to medium tasks - Cost-sensitive applications **Why** - Very cheap - Extremely fast - 1M context window **Estimated cost** - ~$30–40/month - ~$10–15/month with heavy caching > Output tokens usually dominate cost for chatbots. > --- ### Tier 3: Budget Models (Cheapest but Still Good) ### **GPT-5 Mini** **Best for** - Simple tasks - High-volume systems - Budget projects **Why** - Very cheap - Large 400K context window - Fast responses **Estimated cost** - ~$22/month > Poor choice for complex reasoning. > --- ### **Claude Haiku 4.5** **Best for** - Simple workflows - Fast responses - Lightweight assistants **Why** - Cheap and reliable - Good quality for simple tasks **Estimated cost** - ~$50–60/month > Not suitable for complex reasoning. > --- ### **DeepSeek V3.2 (Non-thinking)** **Best for** - Simple chat - High-volume workloads - Budget-first systems **Why** - Extremely cheap - Good enough for basic tasks **Estimated cost** - ~$5–10/month - ~$3–5/month with caching > Avoid for complex reasoning. > --- ### **DeepSeek V3.2 (Thinking Mode)** **Best for** - Math - Logic-heavy reasoning - Step-by-step problem solving **Why** - Very strong reasoning - Much cheaper than premium reasoning models **Estimated cost** - ~$80–110/month > Thinking tokens dramatically increase output cost. > > > Do not use for simple tasks. > --- ### Tier 4: Do It Yourself (Open Source / Self-Hosted) ### **Llama 4, Mistral, Phi** - **Price**: $0 (if you run it yourself) - **Server Cost**: You pay for computers and hosting - **Best For**: Privacy matters, you want full control, high volume - **Good**: Private, you can change it, no API fees - **Bad**: You need to manage servers yourself, takes time --- ## Price Comparison Summary | Model | Input (per 1M) | Output (per 1M) | Monthly Cost* | | --- | --- | --- | --- | | **DeepSeek V3.2 (Cache)** | $0.028 | $0.42 | $4.42 | | **DeepSeek V3.2** | $0.28 | $0.42 | $7.14 | | **GPT-5 Mini** | $0.25 | $2 | $21.75 | | **Gemini 3 Flash** | $0.50 | $3.00 | $33.00 | | **Haiku 4.5** | $1.00 | $5.00 | $57.00 | | **Batch Sonnet 4.5** | $1.50 | $7.50 | $85.50 | | **Gemini 3 Pro** | $2.00 | $12.00 | $132.00 | | **GPT-5.2** | $1.75 | $14.00 | $147.00 | | **Sonnet 4.5** | $3.00 | $15.00 | $171.00 | | **Opus 4.5** | $5.00 | $25.00 | $285.00 | | **GPT-5.2 Pro** | $21.00 | $168.00 | $1,764.00 | Baseline assumes 1,000 daily conversations, 500 input + 300 output tokens each. For reasoning models, “output” may include thinking tokens, so costs can be higher. --- ## Real-World Examples: How to Choose ### Example A: Customer Support Chatbot (Lots of Messages) **What you need**: - 5,000 chats per day - Simple questions and answers - Fast replies - Low cost **Best choice**: Gemini 3 Flash + Context Caching **Why**: - Very cheap ($0.50/$3) - Can handle 2,000 requests per minute - Can store lots of info (1M tokens) - Caching makes repeated instructions free **Estimated cost**: - Gemini 3 Flash with caching: ~$80–100/month - DeepSeek V3.2 + caching: ~$10–20/month (cheapest) - GPT-5 Mini: ~$30–40/month - Claude Haiku 4.5: ~$120–150/month > Note: For chatbots, output tokens usually dominate cost. Caching mainly reduces repeated system prompts and instructions. > --- ### Example B: Code Helper (Medium Use) **What you need**: - ~500 coding requests per day - Correct code matters - Bugs can be reviewed - Medium budget **Best choice**: Claude Sonnet 4.5 (Batch API) **Why**: - Strong at coding and refactoring - Batch API cuts cost by ~50% - Quality is more than enough for production code **Estimated cost**: - Sonnet 4.5 (Batch): ~$100–120/month - GPT-5.2: ~$180–200/month - Gemini Pro: ~$160–180/month > Note: For coding tools, quality differences matter more than raw speed. > > > Batch processing works well because most code tasks are not real-time. > --- ### Example C: Data Analysis (Complex Work) **What you need**: - 100–200 complex questions per day - Multi-step reasoning (math, logic, code) - Accuracy matters - Some results can be reviewed **Best choice**: DeepSeek V3.2 Thinking or Claude Opus 4.5 **Why**: - DeepSeek V3.2 Thinking: extremely cost-effective for reasoning - Claude Opus: safer and more consistent for high-stakes decisions **Estimated cost**: - DeepSeek V3.2 Thinking: ~$80–100/month - Claude Opus 4.5: ~$250–300/month **Rule of thumb**: - If mistakes are cheap or reviewable → start with DeepSeek V3.2 Thinking - If errors are expensive (legal, financial, safety) → Claude Opus is justified --- ## Hidden Costs to Watch Out For ### 1. Wasting Space in Your Prompts If you send longer prompts than needed, you waste money! **Example**: - Your prompt is 5,000 tokens but you only need 1,000 tokens - You're paying 4x more than necessary! **How to fix**: - Make your prompts shorter - Cache the parts you repeat - Delete old chat history you don't need --- ### 2. Too Much Output Some models write very long answers! **DeepSeek V3.2 Thinking Example**: - You ask a simple question - It shows 10,000 tokens of thinking + 500 token answer - You pay for 10,500 tokens instead of 500! **How to fix**: - Use `max_tokens` to limit length - Use simpler models for easy questions - Use non-thinking mode when you don't need reasoning - Ask for short answers in your prompt --- ### 3. Rate Limits Slow You Down When you hit the speed limit → need to try again → waste time and money **Example**: - Gemini 3 Flash: 2,000 requests per minute - GPT-5.2: 500 requests per minute (typical) - If you get busy → GPT-5.2 slows down faster **How to fix**: - Pick models with high speed limits - Add smart retry logic - Pay for enterprise for higher limits --- ### 4. Images Cost Extra Processing images costs different amounts! **Gemini Image Example**: - Input image: $0.0011 per image (560 tokens equivalent) - Output image (1K): $0.134 per image - Process 1,000 images/day = $4,050/month! 💸 **How to fix**: - Make images smaller before sending - Use special image models if needed - Process non-urgent images in batches --- ## 5 Common Mistakes (Don't Do These!) ## Mistake 1: Using an Expensive Model for Everything **Bad** - One premium model for all tasks - High cost, little benefit **Better** - Cheap model for easy tasks - Premium model only where needed **Result** - Save ~60–80% with no noticeable quality loss --- ## Mistake 2: Not Using Caching **Bad** - Re-sending the same instructions every request **Better** - Cache system prompts and shared context **Result** - Input cost drops by ~70–90% --- ## Mistake 3: Unlimited Output **Bad** - Letting models generate very long answers **Better** - Set `max_tokens` - Ask for concise answers **Result** - Output cost reduced by ~50–80% --- ## Mistake 4: Ignoring Batch APIs **Bad** - Using real-time APIs for non-urgent work **Better** - Batch processing for background jobs **Result** - ~50% cost reduction --- ## Mistake 5: Using Thinking Mode for Simple Tasks **Bad** - Reasoning models for basic chat **Better** - Non-thinking model for simple tasks - Reasoning model only when needed **Result** - Save ~80%+ on reasoning workloads --- ## Summary: No Perfect Answer for Everyone After looking at all the prices and options, here's what matters: ### What You Should Remember: 1. **Know What You Need First** - Don't just look at price. Understand your work. 2. **Mix Different Models** - You don't need one model for everything - Easy work → Cheap models (DeepSeek V3.2, GPT-5 Mini) - Medium work → Mid-tier (Gemini 3 Flash, Haiku) - Hard work → Premium (Sonnet, GPT-5.2, Opus) - Save 60-90% 3. **Small Changes = Big Savings** - Caching: -90% - Batch API: -50% - Smart routing: -80%+ - Using the right mode (Non-thinking vs Thinking): big savings - All together: Save over 95%! 4. **Keep Testing** - Start with cheapest models - Check if they work well - Upgrade only if needed 5. **Price Is Not Everything** - How much text it can handle - Speed limits - How fast it responds - Extra features (images, tools, thinking) --- ## Last Words Picking an AI API is not hard when you know what you need. Start simple: 1. Understand what work you're doing 2. Try cheap models first (DeepSeek V3.2, GPT-5 Mini, Gemini 3 Flash) 3. Upgrade only if you must Remember: **saving money = making money**. If you save $1,000/month, that's $12,000/year extra profit. With 10% profit margin, that's like earning $120,000 more in sales! Also, tech gets better and cheaper fast. New models come out every few months with better prices. So check prices every 3 months and optimize. **Rule of thumb:** Start with the cheapest model that might work, measure failure rate, then upgrade only where failures are expensive.]]> https://devmystify.com/blog/hello-world-mcp-building-a-safe-sql-assistant-for-claude-desktop Wed, 14 Jan 2026 11:11:03 GMT { return { tools: [ { name: "get_schema", description: "Get the schema (columns/types) for a specific table. Always run this before querying.", inputSchema: { type: "object", properties: { tableName: { type: "string" } }, required: ["tableName"], }, }, { name: "query_db", description: "Execute a READ-ONLY SQL query. Ensure the SQL is valid Postgres syntax.", inputSchema: { type: "object", properties: { sql: { type: "string" } }, required: ["sql"], }, }, ], }; }); // 4. Handle Tool Execution server.setRequestHandler(CallToolRequestSchema, async (request) => { const { name, arguments: args } = request.params; try { if (name === "get_schema") { const text = ` SELECT column_name, data_type FROM information_schema.columns WHERE table_name = $1; `; const result = await pool.query(text, [args.tableName]); return { content: [{ type: "text", text: JSON.stringify(result.rows, null, 2) }] }; } if (name === "query_db") { // The Postgres user permissions handle the safety, but let's be explicit console.error(`Executing SQL: ${args.sql}`); const result = await pool.query(args.sql); return { content: [{ type: "text", text: JSON.stringify(result.rows, null, 2) }] }; } throw new Error(`Unknown tool: ${name}`); } catch (error) { return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true }; } }); // 5. Start the Transport const transport = new StdioServerTransport(); await server.connect(transport); ``` This code is lean. It doesn't use heavy ORMs. It just passes the strict SQL through our safe connection. --- ### 3. The Wiring: Connecting to Claude Desktop We need to tell the Claude Desktop app where to find our new server. Open your config file: - **Mac:** `~/Library/Application Support/Claude/claude_desktop_config.json` - **Windows:** `%APPDATA%\\Claude\\claude_desktop_config.json`  (Pro Tip: You can often find this quickly via the `Edit Config` button in the Claude Settings) Add your server to the `mcpServers` block: ```json { "mcpServers": { "my-library": { "command": "node", "args": [ "/ABSOLUTE/PATH/TO/YOUR/PROJECT/index.mjs" ] } } } ``` > Troubleshooting Tip: If the server doesn't show up, try using the absolute path to your node executable (e.g., /usr/local/bin/node) instead of just "node". Claude sometimes doesn't know where to look for Node in your system path. > **Restart Claude Desktop.** You should see a little plug icon indicating the tool is connected.   --- ### 4. The "Magic Moment" Now for the payoff. Open a chat with Claude and simply ask: > "I'm looking for some reading material. Find me all books with 'Rails' in the title." > Here is what happens in the background: 1. Claude sees it has a `get_schema` tool. It calls it on the `books` table to understand the structure.  2. Claude identifies the `title` and `author` columns. 3. Claude create a valid SQL query:  4. It calls `query_db`. 5. Our `claude_reader` user executes it safely. 6. Claude replies:  No copy-pasting schema. No fear of data loss. Just a powerful, context-aware SQL assistant living right inside your chat window. --- ### Conclusion MCP is a game-changer. It turns your AI from a passive chatbot into an active participant in your development workflow. The possibilities are endless. I once saw a developer use a Rust SDK to build an MCP server to change memory values in games like *Persona*. Whether it's production data or in-game money, if you can code it, Claude can connect to it. What will you build with MCP?]]> https://devmystify.com/blog/picking-the-right-tool-top-10-programming-languages-to-learn-in-2026 Wed, 07 Jan 2026 08:16:48 GMT https://devmystify.com/blog/local-ai-vs-chatgpt-face-off Wed, 24 Dec 2025 09:28:03 GMT "Generate a Zod schema and TypeScript interface for this API response." > ```json { "user_id": "u_99283", "meta": { "role": "admin", "access_level": 4 }, "profile": { "name": "John D.", "phone": "+66812345678" } } ``` **The Comparison:** **ChatGPT (The Specialist):** It generates standard, working Zod code using `z.object()` and `z.infer`. It correctly identifies types and even adds `.email()` validation automatically. - **Result:** Perfect code, but **you just leaked John Doe's PII to OpenAI.** ```tsx import { z } from "zod"; export const UserApiResponseSchema = z.object({ user_id: z.string(), meta: z.object({ role: z.string(), access_level: z.number().int(), internal_flags: z.array(z.string()), }), // ... }); ``` **Local LLM (Gemma 3:4b):** The data stayed on my machine, so John's privacy is safe. But when I ran the code... it crashed. ```tsx // Generated by Local LLM import { CreateSchema } from 'zod'; // ❌ Error: Module 'zod' has no exported member 'CreateSchema'. export const UserResponseSchema = CreateSchema.impl({ user_id: 'string', // ... }); ``` The local model **hallucinated** a method called `CreateSchema` that doesn't exist in the Zod library. It looked like valid TypeScript, but it was completely broken. **🏆 Winner:** **Draw.** - **Privacy:** Local LLM wins (Data never left the M4). - **Code Quality:** ChatGPT wins (Local LLM invented a fake library method). **The Lesson:** If you use Local AI for sensitive tasks, **you must review the code.** It’s a junior developer that doesn't know the library docs, not a senior architect. --- ## Round 2: The "Boilerplate" Blitz (Speed & Accuracy) Let's say you just need a quick React component or a regex to validate an email. You don't need a genius; you need a fast intern. **The Prompt:** > "Write a regex for validating a Thai phone number." > **The Experience:** **ChatGPT:** The text explodes onto the screen immediately. It gives a robust regex that handles dashes, spaces, and the +66 country code. It even includes a helper function. ```tsx // Accepts: 0812345678, +66812345678, 02-123-4567, etc. const thaiPhoneRegex = /^(?:(?:\+?66|\+?66\s*\(0\)|0)\s*-?)?(?:(?:[689]\d{8})|(?:2\d{7})|(?:[3-7]\d{7}))(?:\s*[- ]?\s*\d+)*$/; ``` **Local (Mac M4):** First, I tried the heavy hitter, **DeepSeek-R1**. I hit Enter... and waited. And waited. 10 minutes later, it was still "thinking." I eventually had to kill the process. The reasoning model was overkill for a simple regex and choked on the local hardware. So, I switched to a smaller model (**Gemma 3:4b**). It was instant, but the output was... confidently wrong. ```tsx // Generated by Local LLM (Gemma 3:4b) const regex = /^(?:\d{2}\.){5,}[A-Za-z0-9\s\-]?\d{4}[A-Za-z0-9\s\-]?$/; ``` It tried to match 5 sets of 2 digits followed by periods…? That looks more like an IP address or a weird date format than a Thai phone number. It was fast, but it was hallucinating. **🏆 Winner:** **ChatGPT.** (Reliability kills) --- ## Round 3: The "Deep Logic" Problem (Reasoning) This is where the rubber meets the road: complex architectural reasoning. **The Prompt:** > "I have a generic retry function that supports exponential backoff, but it's causing a 'Maximum call stack size exceeded' error when the API is down for too long. Analyze this code and fix the recursion issue." > **The Input Code (The Bug):** ```tsx const retryWithBackoff = async (fn, retries = 5, delay = 1000) => { try { return await fn(); } catch (err) { if (retries === 0) throw err; await wait(delay); // ⚠️ The Logic Trap: Recursive call return retryWithBackoff(fn, retries - 1, delay * 2); } }; ``` **The Comparison:** **ChatGPT (The Senior Engineer):** It acts like a Senior Staff Engineer. It immediately spots that JavaScript engines don't handle tail-call optimization well, meaning recursion is dangerous here. It suggests refactoring the entire function into an **iterative `while` loop**, which is stack-safe. *ChatGPT's Solution:* ```tsx const retryWithBackoff = async (fn, retries = 5, delay = 1000) => { let attemptsLeft = retries; let d = delay; // Switched to a loop: Zero stack growth! while (true) { try { return await fn(); } catch (err) { if (attemptsLeft === 0) throw err; await wait(d); attemptsLeft -= 1; d *= 2; } } }; ``` **Local LLM (Gemma 3:4b):** I skipped DeepSeek because of the speed issues in Round 2 and went with Gemma. The result was... confusing. It correctly identified that "recursion is the problem," but its advice was incoherent. It told me: *"The fix is to simply return the result of the wait function without recursively calling it."* If I followed that advice, this is the code I would get: *Gemma's "Fix" (The Junior Mistake):* ```tsx const retryWithBackoff = async (fn, retries = 5, delay = 1000) => { try { return await fn(); } catch (err) { if (retries === 0) throw err; // Gemma said: "Return wait() without recursively calling" // Result: It waits once... and then exits successfully with 'undefined'. // The retry logic is completely gone! return await wait(delay); } }; ``` **🏆 Winner:** **ChatGPT.** (By a mile). ChatGPT gave me production-ready code. The Local LLM gave me a lecture that, if followed, would have silently broken the app by swallowing the error and never retrying. --- ## Comparison Table | **Feature** | **ChatGPT / Cloud** | **Local (Ollama + M4)** | | --- | --- | --- | | **Privacy** | ❌ Risky (unless Enterprise) | ✅ 100% Private | | **Cost** | 💸 $20/mo | 🆓 Free | | **Speed** | 🚀 Fast (Network Dependent) | ⚡ Instant (Hardware Dependent) | | **Accuracy** | 🧠 PhD Level (Their claims) | 🎓 Intern Level (Hit or Miss) | | **Offline?** | ❌ No | ✅ Yes | --- ## Conclusion: The "Hybrid" Workflow So, who wins? If I'm architecting a new micro-service or debugging a cryptic system error, I’m paying the $20+ for ChatGPT. The reasoning capability is simply unmatched. **But for everything else?** Honestly, I’m still going with ChatGPT, but with a business account ($25 / user / month) for the added privacy. I’ll put more time into trying out local LLMs, but for now, ChatGPT, Claude, and Gemini are just too far ahead, and I think they’re completely worth the current price tag.]]> https://devmystify.com/blog/does-ai-actually-boost-productivity-the-hidden-cost-of-easy-coding Wed, 17 Dec 2025 10:08:32 GMT