Function Calling and MCP for LLMs: A Visual Guide

Clear breakdown of how Function Calling and MCP work together. ⚡ MCP makes tool use much easier by standardizing and simplifying integration for LLMs. #AI #LLM #MCP #FunctionCalling #Agents #MachineLearning

These 10 MCP servers are almost all you'll ever need! Curated after months of building. 1. DeepGraph MCP  → Turns code repos into interactive knowledge graphs. → Semantically search code functionalities, analyze dependencies, and explore direct relationships. → 100% open-source. 2. OpenMemory MCP server by Mem0 → Adds persistent memory across MCP clients. → Create a shared memory layer with style, topics, emotions, etc. that works Claude, Cursor, Windsurf, and others. → 100% local and open-source. 3. Firecrawl MCP server  → Lets clients scrape, crawl, search, extract, and deep research websites.  → It can also convert websites into LLM-ready text right in your editor. → 100% open-source. 4. MCP Toolbox for Databases by Google → Build AI Agents with database access. → Integrate tools to your AI agent in less than 10 lines of Python code with built-in connection pooling, and authentication → 100% open-source. 5. Mintlify Docs MCP server → Mintlify now hosts MCP servers baked into your docs  → They made every documentation site on their platform instantly consumable by AI agents.  → Hit any Mintlify docs URL with /mcp, and you get a fully functional MCP server that AI applications can interact with. 6. E2B MCP Server  → Enables MCP clients like Claude Desktop, Cursor, Cline, etc. to execute code in a secure sandbox environment.  → It supports both JavaScript and Python.  → 100% open-source. 7. Hugging Face's MCP server  → Gives agents access to 1M+ models and datasets. → Plus 1000s of Gradio apps on Spaces. → 100% open-source. 8. Browserbase MCP server  → Allows AI agents to spin up and use browser in the cloud autonomously.  → It lets AI Agents navigate websites, fill forms, capture screenshots, and extract structured data automatically. → Supports multiple models and parallel sessions. 9. Figma Dev Mode MCP server  → Allows AI agents to understand Figma designs with design tokens, component hierarchies, and styling data to generate pixel-perfect code. → Select any frame in Figma or paste a link and let AI agents generate React components. → Currently in open beta. 10. DeerFlow MCP server  → Gives any AI agent Deep Research capabilties. → It connects AI Agents with specialized tools like web browsing, knowledge graphs, and private domain tools for writing detailed reports. → 100% open-source by ByteDance. More such AI tools and projects in theunwindai.com: Get access to 100+ AI Agent, RAG, LLM, and MCP tutorials with opensource code - All for FREE. All links in comments below 👇

Sometimes you are just blown away I started a little project of developing a personal note taker. My notes should be stored in a local knowledge graph, with a local LLM sitting on top. No cloud, no sneaky dependencies. Basically, a private and constantly learning assistant that lives entirely on my machine. From the start I knew that I’d need a SPARQL interface. SPARQL is to knowledge graphs what SQL is to databases and most LLMs are familiar with translating into SPARQL queries. Pretty soon I realized there’s no hacky shortcut here. I’d need to roll my own SPARQL tokenizer and parser. That’s when the “Oops, might be too ambitious” thoughts kicked in. Maybe I should "Claude Sonnet 4.0" give it a try. Now, I rarely touch Claude — it’s verbose, rambly, and has this habit of leading you down a rabbit hole only for you to realize 30 minutes later that you’re totally lost. PROMPT: Can you write me a proper SPARQL tokenizer that handles all the major syntax and store it into sparql_tokenizer.rs?” 💥 BOOM. Minutes later, I had a working tokenizer. With tests. Using my own examples. It just… worked. So I tried it again: PROMPT: “Provide a parser using that tokenizer and my data structures in types.rs, just for SELECT queries. Put it in sparql_parser.rs.” 💥 BOOM again. Parser. With tests. Running perfectly. What would’ve cost me dozens of hours was suddenly done in five minutes flat. You still need to design your app architecture and break the work into bite-sized pieces LLMs can digest. But sometimes, you throw a big chunk at it, it swallows and produces an amazing result.

Looking to learn about MCP Toolbox for Databases from Google? I have updated a couple of codelabs and a blog post that I had authored with the latest versions, Toolbox UI and a few new integrations (Gemini CLI anyone). Check them out: ➡️ Blog Post : Tutorial : MCP Toolbox for Databases - Exposing BigQuery Datasets: https://lnkd.in/dnuTqmke. ➡️ Codelab: MCP Toolbox for Databases: Making BigQuery datasets available to MCP clients (https://lnkd.in/dWKvKgAG) ➡️ Codelab: Build a Travel Agent using MCP Toolbox for Databases and Agent Development Kit (ADK) (https://lnkd.in/dC_NDGME) Both the codelabs have been updated to newer versions of MCP Toolbox and coverage of Toolbox UI. #GoogleCloud #MCPToolbox

🧠 A memory leak was costing us $10,000/month in cloud bills... Here's how I tracked it down and fixed it in one line of code. The Great Memory Leak Hunt: 𝗧𝗵𝗲 𝗦𝘆𝗺𝗽𝘁𝗼𝗺𝘀 → Node.js app memory usage climbing steadily → Server restarts every 6 hours → AWS bills skyrocketing → User complaints about slow response Detective Work: 𝗛𝗲𝗮𝗽 𝗱𝘂𝗺𝗽𝘀 → Analyzed with Chrome DevTools 𝗠𝗲𝗺𝗼𝗿𝘆 𝗽𝗿𝗼𝗳𝗶𝗹𝗶𝗻𝗴 → Identified growing objects 𝗖𝗼𝗱𝗲 𝗿𝗲𝘃𝗶𝗲𝘄 → Found the culprit 𝗧𝗵𝗲 𝗕𝘂𝗴: javascript// Event listeners never removed function addUserHandler(userId) {  eventEmitter.on(`user:${userId}`, handleUserEvent);  // Missing: eventEmitter.removeListener() } 𝗧𝗵𝗲 𝗙𝗶𝘅: javascriptfunction addUserHandler(userId) {  const handler = (data) => handleUserEvent(userId, data);  eventEmitter.on(`user:${userId}`, handler);     // Store reference for cleanup  userHandlers.set(userId, handler); } function removeUserHandler(userId) {  const handler = userHandlers.get(userId);  eventEmitter.removeListener(`user:${userId}`, handler);  userHandlers.delete(userId); } 𝗥𝗲𝘀𝘂𝗹𝘁𝘀: 💰 Monthly costs: $10,000 → $2,000 ⚡ Memory usage: Stable at 200MB 🚀 Zero restarts needed 😊 Happy users and accountants Memory Management Checklist:  • Remove event listeners  • Clear intervals/timeouts  • Close database connections  • Nullify large object references What's your most expensive bug story? Share the lesson learned! 💸 #MemoryManagement #PerformanceOptimization #NodeJS #BugHunting #CloudCosts #SoftwareEngineering #TechDebugging

📝 𝐁𝐲𝐭𝐞 #9: The Law of Leaky Abstractions: When Frameworks Hide Failure Modes 𝐏𝐫𝐨𝐛𝐥𝐞𝐦: High-level frameworks (e.g., ORM, RPC, cloud SDKs) can obscure underlying failure modes—timeouts, partial writes, or retries—leading to subtle data loss or duplicate side effects. 𝐏𝐫𝐚𝐭𝐢𝐜𝐚𝐥 𝐬𝐨𝐥𝐮𝐭𝐢𝐨𝐧: Always read framework and library documentation for failure and retry semantics. Instrument and log at the lowest level possible (e.g., raw SQL, HTTP, or socket) in addition to framework-level logs. Write integration tests that simulate partial failures, timeouts, and retries at the transport layer. 𝐆𝐞𝐧𝐞𝐫𝐚𝐥 𝐆𝐮𝐢𝐝𝐚𝐧𝐜𝐞: Trust, but verify: never assume a framework “just works” under all conditions. Make failure modes explicit in your system design and documentation. 𝐑𝐞𝐟𝐞𝐫𝐞𝐧𝐜𝐞𝐬(links in comments): - Joel Spolsky: The Law of Leaky Abstractions - Jepsen Test Reports #knowledge_sharing #abstractions #resilience

Why MCP is so important, because its some features which are following; 1. Sampling: MCP sampling is a unique process where an MCP server requests a large language model (LLM) to generate a "completion" or response. Unlike the traditional client-server model where the client always makes the request, here the server initiates the request to get help from the AI. This is useful for tasks like analyzing data, making smart decisions, or creating content. The protocol also includes a "human-in-the-loop" feature, allowing the user to review and approve the prompt before it's sent to the AI, and the response before it's used by the server. 2. Prompts: MCP prompts are standardized, reusable templates that an MCP server provides to clients. Think of them as pre-written instructions or "menu items" that guide how a language model should behave. They allow developers to create consistent and predictable interactions. Clients can discover these prompts and use them with their own arguments to customize the output. 3. Tools: MCP tools are executable functions that an MCP server exposes to a client. These tools allow a language model to perform actions in the real world. For example, a tool could be used to query a database, call an external API, or run a system command. Tools are designed to be model-controlled, meaning the language model can discover and decide which tool to use based on the user's request. This gives the AI the ability to go beyond simple text generation and interact with other systems. 4. Resources: MCP resources are read-only data entities that an MCP server makes available to a client. They provide contextual information to the language model. Unlike tools, which perform actions, resources are used to get data. This data can be anything from log files and configuration settings to real-time stock prices or images. 5. Transport Protocols: STDIO vs. Streamable HTTP: MCP clients and servers communicate using different transport mechanisms. STDIO (Standard Input/Output): This is a simple, local transport method where the client and server communicate via standard input and output streams. It's ideal for local integrations, command-line tools, and scenarios where the client and server run on the same machine. It's fast and secure but is limited to a single client connection and is not network-accessible. Streamable HTTP: This is a more modern, flexible transport protocol that uses HTTP for communication, but with a unique twist. It allows for a single, long-lasting connection where the server can continuously stream updates and data to the client using Server-Sent Events (SSE). This is perfect for real-time data updates, web-based applications, and scenarios that require multi-client connections and remote access. It's like a two-way conversation rather than a simple request-and-response.

🚀 𝗛𝗼𝘄 𝗜 𝗯𝘂𝗶𝗹𝗱 𝗺𝘆 𝗔𝗣𝗜𝘀 𝘁𝗵𝗮𝘁 𝘀𝗰𝗮𝗹𝗲 - 𝟱 𝗿𝘂𝗹𝗲𝘀 𝘁𝗵𝗮𝘁 𝗜 𝗳𝗼𝗹𝗹𝗼𝘄 (𝗣𝗮𝗿𝘁 𝟭) Whether you are building a simple REST or GraphQL API, these principles are what I have learnt after countless times of building and designing APIs. They save time not just for developers, but make the process more efficient for end-users too. Here are the 5 rules I tend to follow: 1️⃣ 𝗨𝘀𝗲 𝗰𝗼𝗻𝘀𝗶𝘀𝘁𝗲𝗻𝘁 & 𝗰𝗹𝗲𝗮𝗿 𝗲𝗿𝗿𝗼���� 𝗵𝗮𝗻𝗱𝗹𝗶𝗻𝗴 Your API consumers shouldn't have to guess what has gone wrong. Error codes and descriptions make the API structured and easy to understand both in production and development environments. Using standard HTTP status codes (400, 404, 500, etc) makes it easier for developers to get a higher level overview of what went wrong. Lets take a look at status code 404. This is a common status code to signify that the requested resource is not found, which both technical and non-technical users understand. Below is a clear example of how status codes can help: -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- { "𝘴𝘵𝘢𝘵𝘶𝘴": 404, "𝘦𝘳𝘳𝘰𝘳_𝘤𝘰𝘥𝘦": "𝘗𝘈𝘎𝘌_𝘕𝘖𝘛_𝘍𝘖𝘜𝘕𝘋", "𝘮𝘦𝘴𝘴𝘢𝘨𝘦": "𝘛𝘩𝘦 𝘱𝘢𝘨𝘦 𝘳𝘦𝘲𝘶𝘦𝘴𝘵𝘦𝘥 𝘪𝘴 𝘯𝘰𝘵 𝘧𝘰𝘶𝘯𝘥 𝘰𝘯 𝘵𝘩𝘦 𝘴𝘦𝘳𝘷𝘦𝘳" } -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- 2️⃣ 𝗞𝗲𝗲𝗽 𝗽𝗲𝗿𝗳𝗼𝗿𝗺𝗮𝗻𝗰𝗲 𝗶𝗻 𝘁𝗵𝗲 𝗱𝗲𝘀𝗶𝗴𝗻 𝘀𝘁𝗮𝗴𝗲 A slow API is a dead API. Don't wait until production to think about performance based decisions.   • Paginate large datasets to prevent sending large responses - this takes up bandwidth and resources   • Implement a caching strategy like Redis for non-critical data   • Think about how many users you expect to be serving 3️⃣ 𝗦𝗲𝗰𝘂𝗿𝗶𝘁𝘆 Is there data in the API that needs to be kept secure? Does your application allow uploading of files to its service? How do you prevent abuse of your service?   • Implement a login service which authenticates the user on the API   • Ensure that the users have appropriate permissions to carry out an action - should a user be allowed to delete other user's files?   • Enable rate limiting as it helps prevent abuse of your API Status codes: https://lnkd.in/e7HgSx3V Best security practices: https://lnkd.in/eadXkaaq

LEARN MODERN BACKEND – CORE COMPONENTS. 1. Edge (DNS / CDN / WAF) • User: The end-user making requests (via browser, app, or API client). • DNS (Domain Name System): Resolves the human-readable domain (e.g., example.com) into the server’s IP address. • CDN (Content Delivery Network): Caches static content (images, CSS, JS, videos) close to users globally for low latency. • WAF (Web Application Firewall): Protects against malicious traffic (SQL injections, XSS, bots). ——— 2. Entry Layer (Load Balancer / API Gateway) • Load Balancer: Distributes incoming requests across multiple servers to prevent overload and ensure high availability. • API Gateway: Acts as a single entry point for clients. • Handles authentication, rate limiting, request routing, and protocol translation (HTTP ↔ gRPC, etc.). • Useful for microservices because it abstracts complexity from clients. ⸻ 3. Application Layer • Auth Service: Handles authentication (login, JWT issuance, OAuth2 flows, session management). • Centralized identity provider for microservices. • App Service: Core business logic (e.g., order processing, social media posting, analytics). • Communicates with databases, cache, and other services. • Can be multiple microservices depending on business needs. ⸻ 4. Data Layer • Cache (e.g., Redis, Memcached): Stores frequently accessed data in memory to reduce database load and speed up responses. • Used for sessions, tokens, or pre-computed results. • Persistent storage for structured (relational) or unstructured data. • Typically supports transactions, backups, replication, and scaling. • Object Storage (e.g, S3, MinIO, GCS): • Stores unstructured data such as images, videos, backups, and large files. • Highly scalable & cost-efficient. ⸻ 5. Async Layer • Queue (e.g., RabbitMQ, Kafka, SQS): Manages asynchronous tasks like sending emails, processing background jobs, or handling heavy workloads. • Decouples services to prevent slowdowns. • Consumes tasks from the queue and executes them (e.g., generating reports, resizing images, processing payments). • Runs independently of the main request/response cycle. ⸻ 6. Observability Layer • Collects logs, metrics, and traces across all services. • Helps monitor performance, debug issues, and optimize system behavior. • Tools: Prometheus, ELK Stack, OpenTelemetry. • Logs: Text records of events (errors, requests, system actions). • Metrics: Numerical data (CPU usage, request latency, cache hit rate). • Traces: Request path across microservices (useful for debugging bottlenecks). ⸻ 🔑 How It All Works Together ♻️ 1. User request → Edge (DNS/CDN/WAF) → Entry Layer (Load Balancer, API Gateway). 2. API Gateway authenticates → Forwards request to Auth Service → App Service. 3. App Service may fetch from Cache or Database, store files in Object Storage. 4. Heavy tasks go to Queue, processed later by Workers. 5. All layers send logs, metrics, and traces to Observability for monitoring.