Skip to content
W3S101

Using MCP in Gemini

Using MCP in LLM Calls - With Gemini Models

Section titled “Using MCP in LLM Calls - With Gemini Models”

Unlocking Gemini Model Potential with MCP

Section titled “Unlocking Gemini Model Potential with MCP”

Google’s Gemini models represent a significant advancement in multimodal AI. While inherently powerful, their ability to provide the most relevant and actionable responses can be vastly amplified by connecting them to real-time, external, or proprietary information, and by enabling them to interact with other systems. The Model Context Protocol (MCP) is designed to bridge this gap, offering a standardized way for Gemini models to access external data and utilize tools, making them even more versatile and effective.

Consider MCP as a sophisticated intermediary. Your application, when orchestrating interactions with a Gemini model, can use MCP to dynamically fetch required context or to trigger external actions. This allows Gemini to ground its responses in current data and to extend its capabilities beyond text generation or understanding.

Bridging Gemini Models to External Data via MCP

Section titled “Bridging Gemini Models to External Data via MCP”

Through MCP, an MCP server can expose ‘resources,’ which are essentially structured pieces of external data. These could be anything from files in a cloud storage bucket, entries in a NoSQL database, information from a corporate knowledge base, or even live feeds like public transit updates. When an application utilizing a Gemini model requires specific contextual information to enhance its output, it can request this data via an MCP client.

The process is efficient: Your application, prior to making a call to the Gemini API, determines the necessity for external data. It employs an MCP client to fetch this data from an appropriate MCP server (e.g., retrieving a user’s preferences from a profile store). The MCP server delivers the data in a usable, structured format. Your application then incorporates this rich data into the prompt or request structure for the Gemini model, leading to more informed and relevant generations.

  • Example Data Sources: Product inventory databases, academic research papers, user-specific application settings, real-time financial market data.

Empowering Gemini Models with External Tools through MCP

Section titled “Empowering Gemini Models with External Tools through MCP”

LLMs are increasingly expected to not just process information, but also to instigate actions. MCP facilitates this by allowing the definition of ‘tools’—external functionalities that a Gemini model can request to be executed. These tools could range from simple tasks like sending a notification, to more complex operations like interacting with a CI/CD pipeline, making a reservation, or executing a custom data analysis script. When a Gemini model indicates (often via its own function calling or tool use mechanisms) that an action is needed, your application can use MCP to carry out that action.

For example, if a user asks a Gemini-powered assistant to check their upcoming flight status and then, if it’s delayed, to notify their pickup person, the model might first need the flight details. The application could fetch this using an MCP resource. If a delay is found, Gemini could then signal the need to use a ‘send_sms_tool’. Your application would interpret this, use an MCP client to call the specified tool on an MCP server (providing the message and recipient), and the MCP server would handle the SMS dispatch. The success or failure of this tool use can then be reported back to Gemini to formulate its final response.

  • Example Tools: Interacting with IoT devices, managing cloud resources, performing advanced calculations, integrating with third-party service APIs (e.g., Google Calendar, Maps).

Illustrative Scenario: MCP in Action with a Gemini Model

Section titled “Illustrative Scenario: MCP in Action with a Gemini Model”

Let’s imagine a multimodal AI application powered by a Gemini model, designed to help users plan travel itineraries. Here’s how MCP would enhance its capabilities:

  1. User Request: User provides an image of a landmark and says, “I’m interested in visiting this place. Can you find out its opening hours for next Tuesday and book a taxi for me to get there from my hotel at 10 AM?”

  2. Data Retrieval (MCP Resource): The application (after Gemini identifies the landmark from the image) needs its details. It uses an MCP client to query an MCP server linked to a tourism database: mcp_client.get_resource(server_id='tourism_info_service', resource_path='/landmarks/LouvreMuseum/details'). This might return opening hours, address, etc.

  3. Contextual Prompt for Gemini: The fetched data (e.g., {'name': 'Louvre Museum', 'opening_hours': {'Tuesday': '09:00-18:00'}, 'address': '...'}) is provided to Gemini. The application might also fetch the user’s hotel location via another MCP resource if not already known.

  4. Gemini’s Processing & Tool Indication: Gemini processes this information. It confirms the landmark is open and then indicates the need to use a ‘book_taxi_tool’, possibly structuring its request for the tool (e.g., using Gemini’s function calling feature if available and configured): {"tool_name": "book_taxi_tool", "parameters": {"pickup_location": "UserHotelAddress", "destination": "LouvreAddress", "time": "next Tuesday 10:00"}}.

  5. Tool Execution (MCP Tool): Your application receives this. It then uses an MCP client to call the ‘book_taxi_tool’ on an MCP server integrated with a ride-hailing service. Example MCP call (conceptual): mcp_client.execute_tool(server_id='transport_service_aggregator', tool_id='request_ride', params={'from': 'UserHotelAddress', 'to': 'LouvreAddress', 'pickup_time': 'YYYY-MM-DDTHH:MM:SSZ'}).

  6. Result & Final Response: The MCP server executes the tool (books the taxi), and the result (e.g., {'status': 'success', 'booking_id': 'taxi789', 'eta': '15 mins'}) is returned to the application. This result is then fed back to Gemini, which formulates a multimodal response to the user: “The Louvre is open next Tuesday from 9 AM to 6 PM. I’ve booked a taxi for you from your hotel to the Louvre for next Tuesday at 10 AM. The booking ID is taxi789.”

# Conceptual Python-like example for application logic


# mcp_client and gemini_client are assumed to be initialized


# --- Phase 1: Fetching data using MCP for Gemini model ---
def get_landmark_info_for_gemini(landmark_name):
    try:
        landmark_data = mcp_client.get_resource(
            server_id='tourism_info_service',
            resource_path=f'/landmarks/{landmark_name}/details'
        )
        return f"Information for {landmark_name}: {landmark_data}"
    except MCPError as e:
        print(f"MCP Error fetching landmark data: {e}")
        return f"Sorry, I couldn't retrieve information for {landmark_name}."


# Assume Gemini identified landmark_name = "LouvreMuseum" from an image
landmark_name = "LouvreMuseum"
context_from_mcp = get_landmark_info_for_gemini(landmark_name)


# user_request_for_gemini = (
#     f"{context_from_mcp}\n\n"
#     f"User wants to visit this place. Query: Can you find out its opening hours for next Tuesday "
#     f"and book a taxi for me to get there from my hotel at 10 AM? "
#     f"If booking a taxi, please use 'book_taxi_tool' with parameters 'pickup_location', 'destination', and 'time'."
# )


# gemini_response = gemini_client.generate_content(
#    user_request_for_gemini,
#    tools=[tool_config_for_gemini] # Hypothetical tool config for Gemini's API
# )
# extracted_tool_call = parse_gemini_response_for_tool_call(gemini_response) # Hypothetical parsing


# --- Phase 2: Gemini model indicates tool use, executed via MCP ---
# Let's assume gemini_response leads to this (application logic):
extracted_tool_call = {
    'tool_name': 'book_taxi_tool',
    'parameters': {
        'pickup_location': 'UserHotelAddress', # Assume fetched separately
        'destination': 'LouvreAddress',      # From landmark_data
        'time': '2025-06-10T10:00:00Z'       # Parsed and formatted from user query
    }
}


if extracted_tool_call and extracted_tool_call['tool_name'] == 'book_taxi_tool':
    try:
        mcp_tool_params = extracted_tool_call['parameters']
        tool_result = mcp_client.execute_tool(
            server_id='transport_service_aggregator',
            tool_id='request_ride', # This ID is specific to the MCP server's definition
            params=mcp_tool_params
        )
        print(f"MCP Tool execution result: {tool_result}")


        # Provide tool_result back to Gemini for final response formulation
        # final_response_from_gemini = gemini_client.generate_content(
        #     f"Taxi booking result: {tool_result}. Please inform the user."
        # ).text
        # print(final_response_from_gemini)


    except MCPError as e:
        print(f"MCP Tool Error: {e}")
        # Inform Gemini or user about the tool failure

This scenario highlights how MCP acts as a crucial enabler, allowing sophisticated models like Gemini to securely and efficiently tap into external data and functionalities, thereby dramatically expanding their practical applications, especially in multimodal contexts.