The article explains that most so‑called Agentic AI systems are built around a fixed control‑flow loop where an LLM acts as a planner, making them essentially workflows; it then details the reliability, debugging, and cost challenges that prevent true autonomy in production.
The article explains why format constraints alone cannot guarantee correct content in LLM agents, compares JSON Mode, Structured Outputs, and Tool Calling, and provides a step‑by‑step engineering guide—including model‑specific quirks, schema validation, retry loops, and layered fallback strategies—to achieve robust structured results.
The article defines tool hallucination in LLM agents, analyses training bias, context pollution, loop feedback and dialogue inertia as root causes, and proposes multi‑layer defenses—including visibility control, intent verification, runtime gating, architectural isolation, and feedback loops—framed as a system‑engineering challenge rather than mere prompt tweaking.
This article provides a systematic deep‑dive into the Model Context Protocol (MCP), explaining its purpose, architecture, core capabilities, data and transport layers, and step‑by‑step guides for building both local and remote MCP servers with Python, while also covering security, permission, and best‑practice recommendations for real‑world AI applications.
The article analyzes four emerging AI product trends—FLUX 3’s multimodal action‑prediction, ChatGPT Voice’s task‑oriented scheduling, Claude’s zoom‑tool for high‑resolution evidence, and Claude Security’s pre‑commit scanning—to illustrate a broader move from simple answer interfaces toward verifiable, auditable execution loops.
The article argues that the biggest shift in the AI field is not model improvements but GPT becoming an actual employee, urging Java developers to redesign Spring Boot projects from simple REST endpoints to AI‑friendly business capabilities using tools like Spring AI 2.0.
The article breaks down ten core engineering pillars for production‑grade AI agents—including tool calling with MCP, reusable skills, persistent memory, multi‑agent collaboration, workflow orchestration, hooks, observability, sandboxing, prompt‑injection defense, and the role of forward‑deployed engineers—to help turn demo agents into reliable, enterprise‑ready systems.
OpenAI’s GPT‑5.6 release introduces three tiered models—Sol, Terra, and Luna—each with distinct pricing and performance trade‑offs, integrates ChatGPT Work and Codex into a unified platform, and provides detailed guidance on selecting the right tier for architecture, daily development, batch tasks, or large‑scale autonomous projects.
This article compares Spring AI 2.0 and Spring AI Alibaba, detailing their architectures, core capabilities, pros and cons, and ideal scenarios, and explains how the two can be combined to leverage both atomic AI integration and enterprise‑grade multi‑agent orchestration.
Spring AI’s new Session model replaces the fragile sliding‑window ChatMemory, introducing immutable Session metadata, event‑based Turn grouping, configurable compaction triggers and strategies, multi‑agent Branch isolation, and a JDBC‑backed repository to reliably handle long‑running tool‑calling agents.
The article walks through creating a web‑wrapped ChatGPT agent that automatically fetches SVG logos, uses ReAct’s think‑act‑observe cycle, handles memory limits with context compression, coordinates multiple AI workers, and adds safety layers—collectively called Harness—to reliably produce Apple logo animations.
This article compares LangChain4j and LangGraph4j, explaining that the former is an AI capability integration layer for Java while the latter is a state‑graph workflow engine, and guides developers on when to use each based on features such as model access, tool calling, multi‑agent orchestration, conditional routing, checkpointing, and version maturity.
This article walks through configuring Spring AI on Spring Boot 3.5.0 to convert tool‑calling results among JSON, TOON, XML, CSV, and YAML, presenting two approaches—per‑tool converters and a global delegator—complete with code samples, limitations, and sample output for each format.
The author replaces an outdated Node.js technology roadmap with a new, open‑source AI Agent full‑stack development roadmap, outlining seven progressive stages, priority color coding, and practical guidance for developers already familiar with Node.js and frontend fundamentals.
The article breaks down the ReAct reasoning‑acting loop that powers AgentScope's ReActAgent, details its builder parameters, and compares the synchronous call() method with the streaming stream() approach, showing when each should be used for backend processing or interactive UI.
The article explains how Salesforce’s $3.6 billion acquisition of Fin signals a shift from simple chatbot answers to AI agents that execute end‑to‑end business actions, and why Java/Spring Boot developers must expose secure, auditable services rather than merely wrapping large‑model APIs.
Spring AI 2.0 reaches GA, offering a production‑grade, Java‑first AI development path tightly integrated with Spring Boot 4.x, Spring Framework 7.0, and the Model Context Protocol, while introducing upgraded agent tooling, Jackson 3, JSpecify annotations, and streamlined provider SDKs.
This tutorial walks through the functional planning, project layout, core Python code, context management, FastAPI service, and execution steps needed to create a full‑featured AI coding assistant that can generate, explain, refactor, fix, test, and review code.
The Qwopus3.5‑9B‑Coder model, fine‑tuned for agentic coding, tool calling and logical reasoning, offers three formats (Safetensors, GGUF, GGUF+MTP), runs on a 16 GB Mac mini via LM‑Studio, achieves up to 35% throughput gain with MTP, scores 85 on HermesAgent‑20, 100 on ToolCall‑15, and 53.89% on SWE‑bench, matching Claude Opus 4.6 in a 31‑tool adversarial test while highlighting its training tricks and current limitations.
This article presents a panoramic knowledge map of Spring AI 2.0, outlines core components, dependency configurations, key APIs for chat, RAG and tool integration, and provides a concise interview Q&A guide to help developers verify their mastery of the framework.
Spring AI 2.0 RC1 is now on Maven Central, bringing a rebuilt architecture on Spring Boot 4, Java 21 baseline, tool‑calling overhaul, native MCP support, structured‑output enhancements, migration steps, pros and cons, and a detailed comparison with LangChain4j.
This article explains how Spring AI's Tool Calling lets large language models overcome their inability to access real‑time or private data by invoking annotated Java methods, showing step‑by‑step code examples, parameter handling, and the execution flow that bridges model requests with actual method results.
The weekly highlights introduce five cutting‑edge AI models—MiniCPM5-1B, HiDream-O1-Image, X2SAM, LocateAnything-3B and Granite 4.1 8B—detailing their architectures, novel training methods, performance claims such as SOTA on tool‑calling and code synthesis, and providing online demo links and a compute‑gift offering for developers.
This tutorial demonstrates how to integrate Spring AI with Ollama, define @Tool‑annotated weather and translation utilities, register them for automatic chaining, and let a large language model answer queries like “fetch Beijing weather and reply in English” using a concise end‑to‑end example.
Unsloth now lets locally‑run large language models act as real agents by exposing a Model Context Protocol (MCP) interface through a no‑code Studio UI or a llama.cpp + mcp‑cli command line, supporting tool calling, file access, web search, and multi‑model connections with detailed setup steps, hardware guidance, and security cautions.
This tutorial walks through seven incremental stages—starting with a simple while‑True loop and adding tool‑calling, dynamic skill loading, slash commands, JSON persistence, automatic context compression, and a background timed loop—to create a fully functional CLI AI Agent using Ollama and the local qwen3.5 model without GPU or API keys.
The article walks through building a production‑grade AI Agent system using Spring AI, Alibaba's extensions and the Model Context Protocol (MCP), showing how Java's mature ecosystem—security, microservices, data governance, and workflow—makes it the backbone for next‑generation AI‑native applications.
This article explains the Model Context Protocol (MCP), compares it with traditional function calling, and walks through building a Spring Boot MCP server that lets Claude Desktop automatically invoke Java tools, covering architecture, code examples, security extensions, and future enterprise AI integrations.
This article walks through setting up Spring AI with Ollama, explains the tool‑calling workflow, shows two ways to define tools, provides full Maven and YAML configurations, presents runnable Java code for services, chat client, and controller, and addresses common compatibility and dependency issues.
The article examines Model Context Protocol (MCP), introduced by Anthropic in November 2024, tracing its rapid adoption, architectural design—including Host/Client/Server roles, transport layers, security and observability practices—and outlines production guidelines, future roadmap, and current limitations.
MedScope proposes a "Think with Videos" paradigm that lets AI models actively locate and verify evidence in long clinical videos, using coarse‑to‑fine tool calling, evidence‑centric training data (ClinVideoSuite) and a grounding‑aware reinforcement learning objective, achieving superior performance on multiple video‑understanding benchmarks.
The article walks through a JD interview scenario where a candidate explains how a tool‑calling accuracy metric rose from 71% to 94% by detailing the full SFT data‑engineering pipeline, teacher‑model trajectory generation, quality validation, evaluation methodology, and interview‑ready talking points.
AgentScope Java is an open‑source, agent‑oriented framework that brings ReAct, tool calling, memory, multi‑agent collaboration, runtime intervention, plug‑in integration, reactive architecture, GraalVM native images and OpenTelemetry observability to Java, enabling production‑grade AI agents with familiar Java tooling.
This guide walks through building a production‑grade code‑analysis assistant, detailing requirements, architecture, a Node.js tech stack, TF‑IDF RAG implementation, dynamic skill loading, secure tool calls, memory handling, observability, common pitfalls, and paths to scale from a demo to a full‑featured system.
The qwen2API project offers a FastAPI backend and React+Vite frontend that expose the Qwen web chat as OpenAI Chat Completions, Anthropic Messages, and Gemini GenerateContent interfaces, featuring tool calling, image generation, account pool management, multiple deployment options, and various execution engines.
The article explains how LLM‑driven agent tool calls differ from traditional function calls in timing, parameter sourcing, error handling, call‑chain observability, and performance, and it provides concrete examples, failure modes, and interview‑ready summaries.
This article explains why single‑agent LLM pipelines fail when many tools are attached, introduces the Supervisor pattern that separates routing and execution across specialized agents, compares Tool‑Calling and Handoff approaches, provides a complete TypeScript implementation—including hierarchical supervisors—and lists five common pitfalls with concrete fixes.
The article examines why single‑agent setups fail, introduces the Supervisor pattern for clear responsibility separation, compares Tool‑Calling and Handoff approaches, provides a complete TypeScript implementation, explores hierarchical supervisors, and outlines five common pitfalls with concrete fixes.
The article demonstrates how to construct a Spring Boot application that orchestrates multiple AI services using LangChain4j and Ollama, defining intent‑classification and tool‑based assistants, registering them as beans, and routing user requests through a controller to achieve multi‑step intent recognition and task dispatch in a simulated intelligent customer‑service workflow.
This article walks through LangGraph's three‑step tool‑calling workflow, shows how to define tools with the @tool decorator, demonstrates executing calls via ToolNode, provides a complete agent example, explains bind_tools, shares best‑practice guidelines, streaming execution, and a concise recap.
The article examines how large language models function as probabilistic components within deterministic software, discusses fault‑tolerance limits for viable AI use cases, and offers detailed engineering guidance on RAG pipelines, tool‑calling determinism, agent fragility, testing, monitoring, and privacy‑conscious deployment in finance.
The article explains that the fundamental gap between LLMs and Agents is state: LLMs perform single, stateless inferences, while Agents maintain execution history, intermediate results, and goal tracking to enable multi‑step, dynamic decision‑making, but this brings uncertainty, higher token costs, and debugging challenges.
This article explains how LangChain agents use a ReAct (Reasoning‑Acting) loop to decide when and which tools to invoke, shows built‑in and custom tools via the @tool decorator, compares ReAct with GPT‑4 native tool calling, and demonstrates a research‑assistant workflow that cuts report drafting time from hours to minutes.
This article walks through the complete process of building a Spring AI MCP server and client in Java, covering protocol layers, Maven setup, configuration, tool definition with @Tool, bean registration, client integration, common pitfalls, and the language‑agnostic benefits of the MCP protocol.
This article walks through constructing a tiny, runnable AI agent loop that reads a user task, lets the model choose the next step, calls a tool, feeds the observation back, and repeats, then explains how to add harness, memory, permission, and validation layers to make the agent reliable in real‑world engineering environments.
This comprehensive guide systematically explains thirty core terms of AI agents—covering foundational large language models, fine‑tuning techniques, multimodal vision‑language models, agent architectures such as ReAct and CoT, tool‑calling protocols, retrieval‑augmented generation, workflow orchestration, and emerging product forms like autonomous and embodied agents—while detailing the reasoning, trade‑offs, and concrete examples that shape modern agent engineering.
With more than two million LLMs available, this guide explains how to evaluate functional capabilities, latency, throughput, cost, tool‑calling reliability, context‑window size and compliance, and presents a step‑by‑step framework for picking the most suitable model for each business scenario.
This article explains how LLMs use Function Calling to output structured JSON for tool execution, walks through the full multi‑turn tool call loop, shows how LangChain standardizes disparate vendor APIs with BaseTool and bind_tools, and shares practical pitfalls, best‑practice guidelines, and security considerations for building robust agents.
This article analyzes how AI agents extend large language models with perception‑reason‑action loops, comparing them to traditional chatbots and RPA, and demonstrates their planning, memory, tool‑use, and action capabilities through detailed examples and a step‑by‑step research workflow.
This article explains the ReAct pattern—interleaving reasoning and acting for LLM agents—by defining its core loop, comparing it with plain tool‑calling, providing a step‑by‑step hand‑written implementation in JavaScript, showing the LangChain.js wrapper, streaming output, and detailing five common pitfalls and a pre‑deployment checklist.
This article dissects Claude Code's skill system, tracing its evolution from early prompt engineering to the modern skill framework, detailing the loading pipeline, SKILL.md structure, lazy compilation, command routing, and the system's strengths and limitations.
The newly released Qwopus3.5‑v3 model combines higher‑quality reasoning chains, dedicated tool‑calling reinforcement learning, and an act‑then‑refine paradigm, delivering a 5‑point HumanEval boost, a 1.43‑point MMLU‑Pro gain, 31.7% faster inference and 24% lower token cost, while remaining runnable on a 3090 or a 16 GB MacBook, with easy deployment via GGUF, LM Studio, Ollama or llama.cpp.
Using the open‑source ToolCall‑15 benchmark, the author shows that the 27‑billion‑parameter Qwen3.5 model consistently scores full marks while the 397‑billion‑parameter version fails on several tasks, and that the Q6 quantized variant offers the best trade‑off between size and tool‑calling accuracy.
The article traces the evolution from early function calls to Tool Calling 2.0, explaining how Model Context Protocol standardizes tool interfaces, how Agent‑to‑Agent communication enables multi‑AI collaboration, and how Skills combine tool orchestration into autonomous workflows, while also discussing remaining challenges such as intent misinterpretation and security risks.
The author tests Unsloth Studio, a local web UI that unifies model download, execution, dataset handling, training, fine‑tuning and export, supporting GGUF and safetensors formats across Windows, macOS and Linux, and highlights its integrated tool‑calling, data‑recipe workflow, observability features, installation quirks, and target user scenarios.
The article explains how poorly designed prompts cause AI agents to invoke unnecessary or incorrect tools, and shows how a structured prompt template combined with the Model Context Protocol (MCP) and three safety measures can raise tool‑calling accuracy from about 30% to over 95%.
This article breaks down the concept of AI agents for interview preparation, covering their definition, core components like planning, memory, and tool use, differences from plain LLM chats, real‑world challenges, typical use cases, detailed component analysis, and a runnable pseudo‑code example.
This article walks through the design and implementation of a production‑ready Web AI agent that uses FastAPI as the HTTP layer, LangGraph to orchestrate multi‑step reasoning, and MCP to expose external tools, showing how to manage state, integrate multiple LLM providers, and extend the system with persistence, rate‑limiting, and monitoring.
The article introduces GLM‑5‑Turbo, a model specially optimized for OpenClaw autonomous‑agent tasks, details its benchmark superiority on the ZClawBench suite, and walks through a step‑by‑step tutorial that uses AutoClaw and Chrome MCP to create a product‑operations assistant, while also noting token costs and the new Lobster pricing plan.
The article details how the newly released GLM-5-Turbo "lobster" model powers an AI research Lab that automatically generates a complete OpenClaw survey paper—from topic brainstorming and literature mining to outline drafting, manuscript writing, and AAAI‑style submission—within an hour, showcasing benchmark results, prompt templates, and practical skill installations.
Spring AI eliminates SDK fragmentation, side‑car Python services, and operational complexity by providing a unified AI abstraction layer for Java, enabling seamless model switching, RAG, tool calling, and offering concrete performance data and best‑practice guidance for production use.
This article dissects the evolution of LLM prompts into structured, version‑controlled skill packages, explains the AgentSkills specification, details OpenClaw’s implementation, compares prompts, memory, MCP and skills, and provides end‑to‑end examples with code, flowcharts and best‑practice recommendations.
This guide walks you through installing Claude Code and Ollama, pulling and configuring various open‑source models, setting environment variables, and running Claude Code with both local and cloud‑hosted models, while covering context length, performance considerations, and tool‑calling examples.
This tutorial introduces the foundational Agent Loop that powers modern AI agents, explains why it is needed, breaks down its four core components, compares workflow‑based and agent‑based designs, and provides a minimal Python implementation with code, pitfalls, and a concrete RSS‑news use case.
A comprehensive evaluation shows that while diffusion language models achieve higher generation speed through parallel decoding, they suffer from severe causal reasoning and formatting deficiencies, lagging far behind autoregressive models on embodied and tool‑calling agent tasks.
This article presents a rigorous, multi‑dimensional evaluation of the RAG‑MCP framework versus a full‑tool MCP approach on Amazon Bedrock, showing up to 74% token reduction, higher tool‑selection accuracy, lower latency, and better scalability for large tool sets.
The article explains that premature tool calls in LLM agents stem from a data‑distribution bias in fine‑tuning, and it presents practical fixes such as adding non‑tool samples, enforcing a Thought chain, and using negative sampling to teach the model when to think before acting.
The article explains how mcpx reduces MCP tool definition tokens from tens of thousands to a few hundred by discovering tools at execution time, improving accuracy and speed for local large language models while preserving prompt cache integrity.
Ollama v0.14.0 now supports the Anthropic API, letting you run Claude Code locally with open‑source models like Qwen or Llama without an API key, network, or cost, and the article provides a step‑by‑step setup, SDK examples, and an objective assessment of the approach.
This comprehensive guide explains how AI coding assistants like Cursor and Claude Code compute tokens, interact with tools, index codebases with Merkle trees, craft effective prompts, and apply progressive development practices to boost productivity, code quality, and security across real‑world projects.
MCP (Model Context Protocol) is an open standard that lets AI applications connect to external systems through a unified client‑server model, exposing Tools, Resources, and Prompts, while addressing security, permission, and audit concerns to make large‑model deployments more reusable and controllable.
The article examines Anthropic’s evolution from MCP to Programmatic Tool Calling and its recent return to code execution, contrasting it with the author’s Python‑use (AiPy) paradigm, and analyzes the trade‑offs, reliability versus creativity, and implementation details such as Function Calling, CodeAct, and plugin support.
This article explains how to design and implement Human‑in‑the‑Loop (HITL) interactions for large‑model agents on Alibaba's OpenLM platform, covering the challenges of server‑side execution, MCP transport extensions, tool‑calling patterns, timeout handling, and UI rendering strategies across multiple client devices.
This article explains the MCP protocol for AI agents, detailing why a universal tool‑calling standard is needed, how it solves the M×N integration nightmare, the roles and execution stages involved, and demonstrates its use with Cherry Studio while highlighting current limitations.
This article walks you through creating a fully offline, extensible AI programming assistant in Go, using Ollama and DeepSeek‑R1, covering project layout, message formats, function calling, tool integration, a simple WebSocket UI, and future extension ideas.
This article explains why many enterprise AI agents break down in real projects, identifies four common pitfalls—including mistaking agents for chatbots, lacking schema‑level tool logic, missing memory and variable injection, and absent end‑to‑end pipelines—and offers concrete engineering solutions to build robust, task‑driven agents.
This article systematically dissects Google’s open‑source gemini‑cli, revealing how it transforms a traditional command‑line terminal into an AI‑driven collaborative interface by detailing its ReAct loop, tool‑calling mechanisms, context management, and extensible architecture for building similar terminal agents.
This tutorial walks through setting up a Python environment, explains the three essential components of LangChain 1.0’s create_agent API, details the built‑in message types, and demonstrates four streaming output modes using a weather‑assistant example to help developers quickly adopt the new agent framework.
This comprehensive guide explains the underlying principles of AI coding assistants—including token calculation, tool calling, codebase indexing, and Merkle tree synchronization—while offering actionable best‑practice recommendations for prompt engineering, incremental development, documentation, security compliance, and effective team adoption.
This article explains the Model Context Protocol (MCP) – an open, universal standard that lets large language models seamlessly interact with external tools and data – covering its core architecture, why it’s needed, underlying principles, tool‑selection mechanics, a step‑by‑step Python server implementation, and practical usage tips.
This tutorial shows how to use LangGraph’s low‑level API to create a multi‑turn chatbot, define structured state, add model and tool nodes, implement conditional branching for tool calls, and reproduce a ReACT graph agent with a weather‑assistant example.
MCP, a protocol from Anbhropic, standardizes how large language models communicate with external tools, databases, and APIs through a client‑server architecture, offering three communication modes (Stdio, HTTP with SSE, Streamable HTTP) and enabling use cases such as intelligent analytics, knowledge hubs, AI chatbots, BPM, API integration, automated testing, and programming assistance.
This article explains how Baidu Map’s AI navigation system converts spoken queries into accurate map instructions by combining speech recognition, intent parsing, large‑language‑model reasoning, tool calling, and memory‑reflection techniques, showcasing the underlying technologies that enable instant, context‑aware responses.
This tutorial shows how to set up a Python environment, install LangGraph, and use its high‑level prebuilt graph API—specifically create_react_agent—to quickly create a weather‑assistant AI agent with just two lines of code, illustrating the full tool‑calling workflow and ReACT loop.
This article explores the practical integration of AI agents with Model Context Protocol (MCP) to build a smart reporting assistant and automate batch task creation, detailing the technical workflow, tool‑calling capabilities, implementation steps, challenges faced, and the benefits of combining agents with traditional engineering systems.
This article walks through integrating RAG‑based tool calling into a FastGPT workflow to enable AI‑driven customer service that can fetch real‑time train ticket information by invoking external APIs, configuring HTTP nodes, and handling parameters step by step.
The article presents the 12‑Factor Agents framework, adapting the classic 12‑Factor App methodology to large‑language‑model agents and detailing twelve concrete engineering principles—ranging from prompt control and context engineering to human‑in‑the‑loop and stateless design—that together enable production‑grade, observable, and maintainable AI agents.
This article walks through constructing a stateful ReAct‑style LLM agent using LangGraph, detailing the core components—State, Nodes, Edges—defining a weather‑lookup tool with Open‑Meteo, configuring the graph’s nodes and conditional edges, and executing the workflow with streaming to observe each step in real time.
This article explains fundamental AI concepts—including models, prompts, prompt templates, embeddings, tokens, structured output, data integration, RAG, and tool calling—and shows how Spring AI simplifies their use for Java developers building intelligent applications.
Spring AI 1.0 GA introduces a comprehensive suite of AI capabilities for Java developers, including a ChatClient supporting 20 models, vector‑store integrations, RAG pipelines, advanced chat memory, @Tool function calling, model evaluation, observability, Model Context Protocol, and autonomous agents, with examples for major cloud providers.
Spring AI 1.0, the first production‑grade Java AI framework, introduces ready‑to‑use APIs, seamless model integration, enterprise‑level RAG engine, smart tool calling, and three development modes, empowering developers to rapidly build, customize, and fully control AI applications with major model providers like OpenAI, Anthropic, DeepSeek.
Learn how to quickly set up Alibaba Cloud’s Bailei platform to call the open-source Qwen3 large language model, explore its cost‑effective performance, dual‑mode reasoning, multilingual support, and enhanced agent capabilities, and follow step‑by‑step instructions for API key configuration, Cherry Studio integration, and tool‑calling setup.
Discover the Model Context Protocol (MCP)—an open standard from Anthropic that unifies AI model access to external data sources, enabling real‑time search, tool integration, and bidirectional communication, with practical examples, setup guides, and code snippets for developers to quickly build AI‑driven applications.
This article explains how the Model Context Protocol (MCP) enables large language models to retrieve up‑to‑date external information through standardized tool calls, illustrating the complete end‑to‑end workflow with Python code for the MCP server, client, and host, and discussing its advantages for building AI agents.
This article explains the Model Context Protocol (MCP) – an open, consensus‑based standard that lets large language models seamlessly interact with external tools and data, describes its architecture, why it’s needed, how models choose tools, and provides a step‑by‑step Python server implementation with code examples.
This article explains the concept of tool-specific tokens for large language models, detailing how they enable efficient, reliable tool calls, the implementation steps, advantages over JSON, practical advice, comparisons, challenges, and future directions for AI agents.
This article explains the evolution from Spring AI FunctionCall to the newer ToolCalling, introduces the Model Context Protocol (MCP), and provides step‑by‑step code examples for building MCP servers and clients in Java, demonstrating how to integrate large language models with backend services.
This article explains how Spring AI's tool‑calling feature extends large language models by integrating custom Java tools for information retrieval and operations, and provides step‑by‑step Spring Boot 3 examples—including date‑time and weather tools—complete with configuration, code snippets, and execution results.
The article presents Anthropic’s open‑source Model Context Protocol (MCP) – a client‑server framework that standardizes how large language models securely access resources, prompts, and tools (the “HTTP of AI”) – and demonstrates its use through a hot‑fix scraper and a dynamic chatbot that discovers and invokes tools via JSON‑formatted calls.
The article details how the author discovered a bug in Cursor’s closed‑source IDE where correctly registered MCP services, such as a weather query tool, are omitted from the LLM’s tool list, preventing calls, and explains the debugging steps that compared Cursor with the open‑source Cline implementation to pinpoint the registration flaw.
