Integrating MCP (Model Context Protocol) with LangChain4j to access GitHub

Large Language Models (LLMs) have transformed how we interact with software, but they often lack direct access to real-world data and services. The Model Context Protocol (MCP) addresses this limitation by providing a standardised way for LLMs to interact with external systems.

In this article, you'll learn how to use LangChain4j to connect an LLM with GitHub through MCP: it shows how to fetch and summarise GitHub repository commits.

What is MCP?

The Model Context Protocol (MCP) is an open protocol that standardises how Large Language Model (LLM) applications communicate with external data sources and tools. It enables integration between LLMs and various services, allowing them to access real-world data and perform actions through a well-defined interface. MCP follows a client-server architecture built on JSON-RPC where:

• Hosts are LLM applications (like a Java application using LangChain4j) that initiate connections
• MCP clients maintain 1:1 connections with MCP servers, inside the host application
• MCP servers provide context, tools, and prompts to the MCP clients
• The transport layer handles the actual communication between MCP clients and MCP servers. All transports use JSON-RPC 2.0 to exchange messages. MCP supports multiple transport mechanisms: Standard Input/Output (stdio) and HTTP with Server-Sent Events (SSE)
• External datasources can be anything from databases to APIs, file systems, GitHub APIs, or other services

MCP servers can expose three main types of capabilities:

• Resources: File-like data that can be read by clients, such as API responses, file contents, or database records. Each resource is identified by a unique URI.
• Tools: Functions that can be called by the client. These could include operations like querying databases, performing computations or calling APIs (e.g. GitHub APIs).
• Prompts: Pre-defined templates or instructions that guide language model interactions.

Each of these server capability is accessed through specific protocol messages. For example, to use a tool:

• The client discovers available tools through a tools/list request
• Tools are called using the tools/call endpoint with specific arguments
• The server executes the tool and returns results in a standardised format

The GitHub MCP Server

The MCP ecosystem includes numerous servers, primarily implemented in TypeScript and Python, each providing specific functionality to LLMs. These servers enable LLMs to interact with various services and data sources, from file systems to databases, and from search engines to version control systems.

The GitHub MCP server exposes GitHub's functionality through a set of standardised tools that LLMs can discover and use. It can be executed locally on your machine using Docker. When an LLM connects to this MCP server, it can retrieve a list of available tools through the tools/list endpoint. These tools include operations such as:

• Repository management (create, fork, search repositories)
• File operations (read, create, update files)
• Issue and pull request handling
• Commit history retrieval

When an LLM decides to use a tool, it sends a tools/call request with the appropriate parameters (the name of the tool and the parameters of this tool). The GitHub MCP server then executes the corresponding GitHub API operation and returns the results to the MCP client in a standardised format, that the LLM can then process.

MCP in LangChain4j

LangChain4j has introduced a new module that simplifies the integration of MCP servers into Java applications. This module provides a clean API for establishing connections with MCP servers and executing tools through them.

The core components of the LangChain4j MCP implementation include:

• McpTransport: Handles the underlying transport mechanisms for server communication
• McpClient: Manages the connection and communication with MCP servers
• McpToolProvider: Converts MCP server capabilities into LangChain4j tools

Here's how you create an MCP client in LangChain4j:

McpTransport transport = new StdioMcpTransport.Builder()
    .command(List.of("your-command"))
    .logEvents(true)
    .build();

McpClient mcpClient = new DefaultMcpClient.Builder()
    .transport(transport)
    .build();

McpToolProvider toolProvider = McpToolProvider.builder()
    .mcpClients(List.of(mcpClient))
    .build();        

Using LangChain4j and MCP to Connect to GitHub

Let's examine a practical example that uses the GitHub MCP server to summarise commits from a public repository. First of all, to interact with GitHub, you need to execute the GitHub MCP server in Docker. To build the Docker image, you can follow these instructions.

Once the GitHub MCP server is up and running, you can connect to it using LangChain4j. For that, you first need to set up the AI model (here we use OpenAI's GPT-4o-mini model):

ChatLanguageModel model = OpenAiChatModel.builder()
    .apiKey(System.getenv("OPENAI_API_KEY"))
    .modelName("gpt-4o-mini")
    .logRequests(true)
    .logResponses(true)
    .build();        

Next, you configure the MCP transport layer to communicate with the GitHub MCP server using Docker. Notice the docker command that starts the container mcp/github:

McpTransport transport = new StdioMcpTransport.Builder()
    .command(List.of("/usr/local/bin/docker", "run", "-e", "GITHUB_PERSONAL_ACCESS_TOKEN", "-i", "mcp/github"))
    .logEvents(true)
    .build();        

You then create an MCP client and tool provider:

McpClient mcpClient = new DefaultMcpClient.Builder()
    .transport(transport)
    .build();

McpToolProvider toolProvider = McpToolProvider.builder()
    .mcpClients(List.of(mcpClient))
    .build();        

Finally, you create an AI service and use it to interact with GitHub by asking to summarise the last 3 commits:

Bot bot = AiServices.builder(Bot.class)
    .chatLanguageModel(model)
    .toolProvider(toolProvider)
    .build();

String response = bot.chat("Summarize the last 3 commits of the LangChain4j GitHub repository");
System.out.println("RESPONSE: " + response);        

The response will be something like:

Here are the summaries of the last three commits in the LangChain4j GitHub repository:

* Commit SHA: 1a8a70e
  * Date: February 18, 2025
  * Author: Dmytro Liubarskyi
  * Message: "docu: added tools <-> MCP links"
  * Details: This commit added documentation links between tools and MCP.

* Commit SHA: d755ae5
  * Date: February 18, 2025
  * Author: minglu7
  * Message: "Fix deprecated methods in DefaultContentInjector (#2505)"
  * Details: This commit addressed deprecated methods in the `DefaultContentInjector`

* Commit SHA: 55484f2
  * Date: February 18, 2025
  * Author: SylvestrePinget
  * Message: "Removing amazon.titan-text-express-v1 and ai21.jamba-instruct-v1:0 in ITS (#2532)"
  * Details: This commit removed legacy models, `amazon.titan-text-express-v1`        

Under the Hood

For the LLM to be able to answer the user's question about the last commits, many interactions need to happen:

• The MCP Client sends a tools/list request to the local GitHub MCP Server. The server sends back the list of the available tools, such as list_commits, list_issues, etc.
• The LLM picks up the tools which it thinks is appropriate, here list_commits.
• The MCP Client sends a tools/call request to the MCP Server passing the tool name list_commits and the needed parameters (the last 3 commits).
• The GitHub MCP Server uses the GitHub API to remotely get the last 3 commits from the GitHub Server.
• The Application sends a request to the GPT 4o Mini language model to summarize the last three commits passing the user's prompt as well as the last 3 commits.
• The GPT 4o Mini model responds with the summaries of the last three commits.

Conclusion

MCP provides a powerful way to extend LLM capabilities by enabling standardised access to external tools and data sources. LangChain4j's implementation makes it straightforward to integrate MCP servers into Java applications, requiring minimal setup and configuration.

MCP faces the challenges of establishing itself in the rapidly evolving AI landscape. Wider adoption and community contributions will be crucial for MCP to become the de facto standard for connecting LLMs with external tools and services.

You can find all the code of this article in the LangChain4j Sample repository.

Where to Go Next

To learn more about MCP and LangChain4j, you can explore these resources:

• MCP: https://modelcontextprotocol.io
• MCP specification: https://spec.modelcontextprotocol.io
• MCP GitHub repository: https://github.com/modelcontextprotocol
• MCP GitHub Server: https://github.com/modelcontextprotocol/servers/tree/main/src/github
• LangChain4j: https://docs.langchain4j.dev
• LangChain4j MCP documentation: https://docs.langchain4j.dev/tutorials/mcp
• LangChain4j MCP GitHub server sample: https://github.com/langchain4j/langchain4j-examples/tree/main/mcp-github-example