Github Custom Agent for Creating Neo4j Python Clients

I work for Neo4j as a senior partner architect focused on the GitHub and Azure partnership.

What I want to show today is how I set up a project to use the new custom agents for GitHub Copilot to create a specialized agent that creates a Python client library for your Neo4J database.

And the way I'm going to do this is to leverage the Neo 4J MCP server that has three basic tools.

Two of those are to query the database and execute read and write cipher queries.

And the third tool is a schema tool that allows you to introspect the database and get the schema which contains a list of all the nodes and relationships in the database.

And to start this off, I've already created an instance of Neo 4J aura, and loaded it up with a, knowledge graph of aviation data.

And that contains all the operational maintenance aspects of an aviation fleet to capture aircraft, flights, airports, system sensors.

So for example, for this aircraft we can see all of its related information, such as maintenance events, flights, et cetera.

And so now that I have this database set up, what I need to do to create the agent is because they're leveraging SAP server capabilities, the agents have to be created at the organization level.

So inside of the Neo4j partner organization, I've created a special repo called GitHub, Private.

Inside that repo, GitHub, it's going to create the agents that will be available across the entire organization.

I have two agents that run the MCP server.

One uses Python to run the server and the other runs the MCP server in a Docker container.

And we'll just look at the docker one.

We go and look at the markdown for this.

At the top of the markdown I'm defining the MCP server and how to run it.

And so all it's saying is run this MCP server in Docker and pull the image from this location MCP Neo 4J Cypher latest and set up the environment using these environment variables.

And one key thing is the environment variables have to be named copilotmcp, underscore and then I tell what this agent does.

So I'm saying it's a Python client generator.

I give it the core mission to create a basic, well structured Python client.

I tell it the FCP server capabilities, then I tell it the process for generating the workflow, I give it the requirement analysis phase, a client generation phase, and tell it the structure of the client that you should generate, File by file guidelines.

And then I have a quality assurance phase to be sure that it's followed the best practices, and ensures that it has proper security and tell it what to include and what not to include.

Now that I've created those custom agents at the organization level, to leverage those, all I have to do is create a repository in that organization, and then go to Settings and add the necessary environment variables.

So the MCP server knows how to connect to the Neo4j server.

And then the rest of these files are just sample files that show how I set up the agent at the organization level.

And to use that custom agent, you can use it in two ways.

One is by going to the agents panel and describe the coding task and then I can select a custom agent and I can select one of the two agents I have.

One is the docker, the other one is the one that runs the MCP server with Python.

and the other way you can trigger this agent is by creating an issue.

And once we create the issue, we can assign to copilot.

And when you assign to Copilot, you can select the agent to work on this issue.

So I'm going to select the Neo 4J Docker client generator agent and, and assign that to Copilot.

And then I'm going to go ahead and create this issue.

And this is going to create the issue.

And then we'll see the copilot says it's looking at the issue and we'll see that it fires off and creates a pull request.

And then I can open up the pull request.

And we can see that in here Copilot has started to work on this issue.

if we go to the agents page in GitHub, we, can see the work that Copilot is doing on that issue.

And so what we'll see is it's spinning up the environment and then starting to work on it.

Then others will take about 10 to 15 minutes.

So I'm going to show you one that I created previously.

Let me go to this one.

So this is one I previously created.

what we see that does is it first it sets up the environment.

Most importantly, it starts up the MCP server and loads the MCP server and inspects and gets the tools available, which are the get the schema, read and read, write, cipher.

And then we see that it's beginning the custom agent, the Neo 4J Docker.

And then we can see the steps it goes through.

It inspects the repository, inspects the environment.

And then most importantly, it calls to get the Neo4J schema.

And when it gets the schema it returns that as JSON.

So now that it has the Neo4J schema in JSON, it's going to use that to create a client and as well as the associated, you know, models and repository and tests for that client and then at the very end we'll see that, you know it gives a summary of the steps it took and the documentation it created, the key features that it implemented and then we can go and look at that pull request that it's created and it gives us an overview of the package structure it created, the repositories created, how to use the client, the security the files added, some warnings of issues it faced.

We look at the files that it created, it created an example usage file, a model file based on the schema repository files and tests.

So we can see this custom agent has made it really easy to create a basic Python client to get started working with Neo4J database.

Let me know what custom agents you end up creating and what unique ways you find to leverage the Neo 4J MCP server.

Thank you for watching.