Ep43: MCP Java SDK + Naive RAG vs GraphRAG

In this episode, we dive into the latest upgrades in Neo4j tooling, along with recent bug fixes and enhancements in the LLM Knowledge Graph Builder. We also explore a new preview feature for Java object mapping in the Neo4j Java driver and check out the MCP Java SDK. Next, we highlight the new "Using Neo4j with Java" course on GraphAcademy and unpack a compelling Weaviate article on RAG vs. GraphRAG, featuring Microsoft’s GraphRAG methodology. Whether you're a Java dev, graph enthusiast, or AI-curious, there's something in here for you!

Episode Transcript

(00:05):
You are listening to the BreaktimeTech Talks podcast, a bite-sized tech
podcast for busy developers where we'llbriefly cover technical topics, new
snippets, and more in short time blocks.
I'm your host, Jennifer Reif, anavid developer and problem solver
with special interest in datalearning and all things technology.
There were a few things at Neo4j thatgot upgrades over the last week that I've

(00:28):
run into issues with or been exploring.
Plus, I have news on theGraphAcademy Neo4j with Java courses.
I'll share all the latest goodies there.
Then I read an article fromWeaviate talking about naive versus
GraphRAG and combining a vectordatabase, graph database and the
Microsoft GraphRAG methodology.
Let's get going.

(00:48):
The first topic I want tocover today is that Aura Free.
Our free tier for GraphRAG cloud databasegot an upgrade over the last week or so.
And most of this would've beenvery seamless to the end user.
it was pretty much for me too, althoughI did have one little bug where I
started spinning up an instance aboutthe time they were in the upgrade, which

(01:10):
caused a couple little issues there.
But that got resolved pretty quickly.
But I've noticed that they've upgradedsome things in the Aura Console as well.
I wanted to kind of chatthrough a little bit of that.
The first one is that if you usedata importer through our Aura
console, you now have a couple ofoptions for importing the schema.
The first one is to do it manually, whichis what you've always done if you've

(01:32):
done this before, where you map thetables and columns or files or schemas
coming from other systems, and you mapthose to a graph schema, if you will.
The second option is actually to havethe schema generated from the CSV
files or flat files you're importing,which did a somewhat decent job.
There were several things I wanted totweak, like labels on nodes and things

(01:56):
that didn't, just didn't look overly nice.
I would say they copied the CSV filenames as the node labels and stuff,
which wasn't the greatest experiencethere, but it didn't do too badly.
And then the third option is anAI generated schema, which from my
perspective, did the absolute bestactually, and was really, really fast.

(02:16):
I really loved this.
There's a disclaimer there thatsays, make sure you check the
schema that gets generated.
Of course, you always wanna do thatfor anything AI generated, but I really
thought this did an excellent job.
There were a few tweaksthat I had to make.
There were, I think, a couple ofmissing relationship properties.
I wanted to fill in some of therelationship types with better names
and such that were more descriptive.

(02:37):
But overall, it got the structure and itnamed the nodes correctly and all of that.
It looked really nice.
This is definitely an improvement overjust a manual input because you spend
a lot of time in the manual rendition,just mapping point, click, map column
from this table or this file tothis one in the graph and and so on.

(02:58):
It's just a little bit messierand more time consuming.
The AI generated one definitelycut down on the time and effort you
had to spend there, but you can'tjust use it outta the box either.
Just be aware.
There will be a, probably a couple oftweaks you have to make but it is much
better than doing it all manually.
So I was really excited to see that.
The second thing is that ourLLM Knowledge Graph Builder

(03:21):
tool got some updates as well.
There were a few bugs thatgot introduced when the Aura
Database updated on the backend.
It broke just a couple of thingsin the Knowledge Graph Builder.
I opened a couple of GitHub issues andthose are pretty much resolved now.
It was a really fastturnaround from the team.
They had fixes within a day or twothat I could test and some back and

(03:43):
forth on the discussions on GitHub.
Response was excellent and super fast.
I'd get up in the morning and there'dbe a new comment or a new update to
something and I would test some thingsAnd then by the next morning they'd have
everything again, ready to go a fix ready,and try this and does this look right?
It's just really good experience so far.
The dev version for the LLM GraphBuilder has those fixes in place.

(04:04):
Everything is looking good there,but the push to production has
not occurred just yet, but thatshould be pretty soon, I think.
I had a couple of different issues, that,again, had some like sub-issues going
on there and within a week, less than aweek stuff is fixed and hopefully will
be moving into the production rendition.
So excellent response there.
I'm super excited about using some ofthe new capabilities that are there too.

(04:26):
The LLM Graph builder has some newthings that are available as far as like
the schema mapping, graph enhancementsection of the knowledge graph builder.
So if you haven't checked thoseout, definitely take a peek there.
The next topic I wanna talk about isthat there is a new Java object mapping
preview feature in the Neo4j Java driver.
Now, this was something that wasinteresting because I may have

(04:47):
mentioned it on the podcast before,but the Neo4j Java driver did not used
to map the results coming back fromNeo4j to your Java domain classes,
which kind of seemed odd to me whenI first came across this missing
feature, I guess if you wanna call it.
That when you're dealing with Java,typically, you almost always map

(05:07):
,to your domain classes, right?
The Java driver did not let you dothat previously, and now they have
a preview feature that will mapNeo4j results coming back instead
of generic data types coming back.
You now can map all of that data intoyour Java objects that might be your
domain classes in your application.
This is super exciting to have.

(05:29):
It is a preview feature, which means itwill be going general availability, ga,
but the update iterations for previewfeatures are much faster right now.
So they can iterate and move thingsalong and fix things much faster
than the standard release cycles.
They outline a little bit of whatpreview features entail in the
Java driver GitHub repository.

(05:51):
If you're interested what all thatmeans, feel free to check that out.
But I am working on a sample applicationto showcase this functionality, but I
did get pulled into some other thingsthis week, so I got a little sidetracked.
I will come back to that and Iwill hopefully have an update.
And some GitHub repository code,maybe some content around that
showcasing this new feature.
Now, if you do need a more fullfeatured object graph mapping type of

(06:14):
functionality, the um, Github discussionthat this object mapping feature is
under does mention that you probablyshould use something more full fledged.
For instance, in the Spring ecosystem,you can use the neo4j-ogm library, the
Object Graph mapper library, that providesa lot more capability and full features.
But this does give you a reallygood start if you're just using the

(06:34):
Neo4j Java driver and you just needsome basic object mapping with Java.
Then the next thing I came acrossas a colleague at Neo4j sent me the
MCP Java SDK GitHub repository link.
This is really cool because MCP hasnow released a Java SDK, so you don't
have to just work with Python orJavaScript, which is the kind of the

(06:55):
typical AI applications right now.
You now have a Java interface too.
This enables Java applications tointeract with AI models and tools
through a standardized interface.
They're also, as part of the MCPJava SDK, it includes a Spring AI
MCP, which will add Spring bootintegration for your starter projects.

(07:17):
You can use this in SpringInitializer to add these starters.
I actually tested this out.
I went out to Spring Initializer,typed in MCP, and they popped up
the Spring AI integrations with MCP.
This is super exciting.
Again, the Java SDK includesthings past Spring as well,
but just some options for you.
If you're a non-Spring developer ora Spring developer, you have options

(07:37):
to utilize this new MCP Java SDK.
So I'll include the GitHubrepository link in the notes.
Finally, the last bit that I got to thisweek was GraphAcademy and Neo4j courses.
The new Using Neo4j withJava course is now live.
I talked a little bit aboutthis course in earlier episodes,

(07:57):
but it's a starter course.
It's a free online self-pacedcourse that you can take.
It introduces the Neo4j Java driver basicsin a framework list application format.
This is hopefully a better on-ramp forstarting to use Neo4j with Java, so feel
free to take that course and see whatyou think and provide feedback on that.
Then we also do have a full applicationcourse for working with Neo4j and Java.

(08:22):
That does need quite a bit of a revampthough, which is actually what I've
been working on most of the week.
I plan to go in and simplify theapplication, integrate some of the
feedback that we've received overthe last couple of years that it's
been live, and upgrade a lot ofthe library versions because it
has not been upgraded in a while.
And some of those library versions,the dependencies are a little
bit outdated, to say the least.
So I'm going back and fixing that, andhopefully we'll have some updates there.

(08:45):
But it's quite a bit of a spaghetti ballto disentangle everything, pull things
apart, plus update the course content too.
The piece of content that I wannahighlight for this week, I came across a
really great article from Weaviate, whichis a vector database company by the way.
called Exploring RAG and GraphRAG,understanding when and how to use both.
It talks a little bit about RAG ingeneral, kind of similar to how I talk

(09:09):
about retrieval augmented generation,what it is, how it works, and so on.
And then they go into detail on somenaive RAG versus GraphRAG talks.
First a little about what is naive RAG.
Which it's a vector only RAG or vectorsimilarity search RAG, if you will.
The full article also includes arecipe that you can run with Colab,
which I thought was really cool.

(09:30):
And then they go into the GraphRAG piece.
This is from Microsoft'ssolution perspective, though.
So if you're not familiar with MicrosoftGraphRAG and their approach, it covers
the architecture and construct a demothat uses Weaviate for the vector
search piece, Neo4j for the knowledgegraph piece, and the Microsoft
GraphRAG for the methodology piece.

(09:51):
And it has a connected GitHubproject that's linked in the blog
post, which I think is really cool.
They go over the financial contractsdata set that they're using to
back the application, and the postgoes into some details on different
approaches you can do for GraphRAG.
The one that I am most familiarwith is that local search option.
There's two others thatare in there as well.

(10:12):
But, typically when you go withthe standard RAG, I would say,
you do a vector similarity search,and then you tack on a retrieval
query that pulls related entities.
That is gonna be that local searchapproach that they talk about.
That's what Spring AI uses, Ibelieve Langchain4j, and a lot
of the other providers as well.

(10:32):
Then the article wraps up with somelimitations of GraphRAG, things like
re-indexing data and hyper nodesor nodes that skew results, these
are kind of common graph problems.
And then summarize overall highlights ofthe article and topics they've covered.
This was another busy week findingbugs and testing product updates
in Neo4j, and then diving intothe GraphAcademy Java application

(10:52):
course to make some major revisions.
Finally, I read an excellent articlefrom Weaviate, discussing when and how to
use naive or vector RAG versus GraphRAG.
Talk to you again next week.
Thanks for listening and happy coding.