Sri Satish Ambati

What is Function calling & MCP for LLMs? (explained with visuals and code) Before MCPs became popular, AI workflows relied on traditional Function Calling for tool access. Now, MCP is standardizing it for Agents/LLMs. The visual below explains how Function Calling and MCP work under the hood. Today, let's learn: - Function calling by building custom tools for Agents. - How MCPs help by building a local MCP client with mcp-use and using tools from Browserbase MCP server. In Function Calling: - The LLM receives a prompt. - The LLM decides the tool. - The programmer implements a procedure to accept a tool call request from the LLM and prepare a function call. The tool call request is found in the LLM's response when you prompt it. - A backend service executes the tool. This Function Calling takes place within our stack: - We host the tool. - We implement a logic to determine the tool to invoke and its parameters. - We execute it. So Function Calling requires us to wire everything manually. MCP simplifies this! Instead of hard-wiring tools, MCP: - Standardizes defining, hosting, and exposing tools. - Makes it easy to discover tools, understand schemas, and use them. - Demands approval before invoking them. - Detaches implementation from consumption. For instance, whenever you integrate an MCP server, you never write a line of Python code to integrate the tools. Instead, you just integrate the MCP server and everything beyond this follows a standard protocol handled by the MCP client and the LLM: - They identify the MCP tool. - They prepare the input argument. - They invoke the tool. - They use the tool’s output to generate a response. Everything happens through a standard (but abstracted) protocol. So here’s the key point: MCP and Function Calling are not in conflict. They’re two sides of the same workflow. - Function Calling helps an LLM decide what it wants to do. - MCP ensures that tools are reliably available, discoverable, and executable, without you needing to custom-integrate everything. For example, an agent might say, “I need to search the web,” using function calling. That request can be routed through MCP to select from available web search tools, invoke the correct one, and return the result. Check the workflow in the diagram below. In this setup, to build a local MCP client, I used mcp-use because it lets us connect any LLM to MCP servers & build private MCP clients, unlike Claude/Cursor. - Compatible with Ollama & LangChain - Stream Agent output async - Built-in debugging mode, etc Find the mcp-use GitHub repo in the comments! ____ Find me → Avi Chawla Every day, I share tutorials and insights on DS, ML, LLMs, and RAGs.

269

11 Comments

Among other things, my team has been focusing on AI research for agents. We just blogged about a recent project: the Test-Time Diffusion Deep Researcher (TTD-DR). This framework uses a Deep Research agent to draft and revise its own drafts using high-quality retrieved information. This approach achieves new state-of-the-art results in writing long-form research reports and completing complex reasoning tasks. The work achieves better results than any other deep research agent we compared to. It also shows that self-evaluation and self-improvement are must-have components of a successful agent. https://lnkd.in/gBZpVMQy

296

8 Comments

Having worked on Agentic systems and open source multi agent deployments for last 2.5+ years (Starting with Langchain and moving to Langgraph, Autogen, Google ADK and many others) two common theme that has come across from deploying Agentic solutions and building using Agentic ecosystems in large scale production systems are - Theme 1 -> Agentic AI is shifting from experiment to enterprise backbone—but its ROI hinges on mastering cost containment and correctness at scale. In multi‑agent ecosystems, uncontrolled reasoning calls lead to spiraling spend with unpredictable accuracy (hence its very important to balance the choice of models, fault tolerant modes and accuracy metrics being defined both at Agent, Tool and Orchestrator levels). The winning CIO strategy is layered orchestration: lightweight models for routing, specialized LLMs for high‑value reasoning, and evaluator agents for correctness. This approach converts raw compute consumption into governed, auditable AI “throughput,” reshaping AI from an R&D cost center into a measurable productivity engine. Theme 2- > Standards like Google’s ADK and the Agent‑to‑Agent (A2A) protocol now provide the backbone for this transformation. By enabling a common language for agent communication, context‑sharing, and validation, they allow enterprises to modularize their AI stacks—aligning model choice with both business logic and budget. The value add: reduced infrastructure burn, accelerated time‑to‑market, and AI systems with built‑in accountability. For CIOs, this means a direct path to higher ROI curves where innovation can also take into account the true business value and cost of running these multi-agentic systems in production. #AgentAI #AgentOrchestration #CIOInsights #AIfrastructure #ADK #A2AProtocol

171

12 Comments

Found an interesting paper today. AI agent LLMs need robust tool evaluation. Current benchmarks struggle with diverse MCP tools, complex parameter reasoning, varied API responses, and accounting for real-world tool success rates. MCPToolBench++ addresses this: A large-scale, multi-domain benchmark for AI agent MCP tool use. It leverages over 4,000 MCP servers from 40+ categories, featuring both single and challenging multi-step questions. Data generation uses an automated pipeline, including tool sampling, query generation with "Code Dictionaries" for specific inputs, and rigorous validation steps. Evaluation uses two key metrics: 1. Abstract Syntax Tree (AST) Score for static call accuracy, and 2. Pass@K Accuracy for actual tool execution success. A critical finding is that AST and Pass@K rankings often diverge. This means a model might correctly infer the tool and parameters (high AST) but fail during real-world execution (low Pass@K) due to factors like inconsistent tool success rates or parameter errors. Root cause analysis reveals common failures like "Parameter Errors," "API Error," and domain-specific issues (e.g., invalid map coordinates). MCPToolBench++ is crucial for developing more reliable AI agents. Arxiv link: https://lnkd.in/g6fEBM9D #AI #LLMs #AIAgents #MCP #Benchmark #ToolUse

89

3 Comments

Strong start yesterday — great mix of Datacolor AI engineers, UTD students, and AWS/Informatica mentors diving deep into what Agentic AI really means at an enterprise scale. We spent the day iterating on technical patterns, how to build multi-agent orchestration pipelines ,use AWS Bedrock, Claude, and LangGraph, while linking to Informatica’s metadata and data-governance APIs for trusted, context-aware execution. Students from The University of Texas at Dallas brought serious curiosity — some experimenting with the Model Context Protocol (MCP) runtime to connect agents to real business systems For us, this hackathon isn’t about demos — it’s about giving back: sharing frameworks, mentoring students, and helping build the next generation of AI engineers who understand both the model and the system.

60

4 Comments

We're introducing Stax, an experimental developer tool to streamline LLM evaluation with custom and pre-built autoraters. Stax is an AI evaluation platform that allows you to assess and benchmark generative AI models and applications against your specific needs and criteria. In contrast to general leaderboards, Stax helps you understand how an LLM or prompt will perform for your use cases. Testing AI is challenging due to the absence of a single "right" answer and it's non-deterministic nature. Stax provides a platform to measure the quality of AI-generated content, ensuring it aligns with your unique standards and criteria. With Stax, you can: ⚡ Experiment Rapidly: Use the "Quick Compare" feature to test different prompts across various models. 🌐 Evaluate at Scale: Utilize "Projects & Datasets" to run extensive evaluations on large sets of data. ✅ Define Your Own Criteria: Create custom evaluators tailored to your specific use case or use pre-built system evaluators for common criteria like fluency, groundedness, and safety. 📈 Analyze Performance: Visualize evaluation results and performance metrics on the Analytics page to gain insights into model behavior. Go try it now: https://lnkd.in/e_YvmrHC

54

2 Comments