Ep32: Official CLI + Bread Code Framework

In this episode, I’m following up on a few things I’ve mentioned before. I dive into some updates on the Aura CLI (the official product version). I also explored the Neo4j GenAI Java library a bit more, including a connection hiccup I ran into with Neo4j Desktop. Then, I get into my experience with the Cypher DSL library and how Cypher fits into the retrieval part of RAG systems. Finally, I take a fun detour into an interesting article about a GitHub repository that combines coding and sourdough baking. It’s a cool reminder that the skills we learn in coding can apply to all sorts of other areas, even in the kitchen!

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 data,learning, and all things technology.
If you are new here on Breaktime Tech Talks, welcome.

(00:27):
I would encourage you to check out thefirst episode in the series where I
introduce what this podcast is all aboutand provide a little bit of my background.
It really just sets the stage forthe things we talk about here on
the show as well as just mygoals and my aims for this podcast.
It's actually really rainy and drearyhere today outside, but I have a

(00:51):
couple of things to follow up on thatI've mentioned in previous week's
episode, and I want to do that today.
I've played a little bit more with theAura CLI that I talked about last week,
and I have some important updates on that.
Then, I was working a bit more withthe experimental GenAI Java library,
and that dropped me into a couple ofmore learnings, and then adding the
Cypher DSL library to my repertoireand experience this week, too, and

(01:14):
some things that go along with that.
Lastly, I came across a fun andinteresting article on a developer
turned baker with a bread-makingGithub repository.
Without further ado, let's start right in.
The first thing I explored was justlooking at the Aura CLI a little bit more.
I talked about this last week that Iwas getting started with it and ran

(01:35):
into a couple little issues andwanted to kind of follow up this week.
And I found out that there's actuallytwo different versions of the Aura CLI.
There's a Neo4j Labs
version, which is kind of the incubatoror beta version of the project.
And then there's the official Neo4jreleased product version of the Aura CLI.

(01:55):
And that was the most recent release.
I ended up, I looked and I wasusing the labs project when I was
running into some of these issues.
I was getting an error access deniedwhen I was running the command
that just listed my instances.
And so I pinged a couple of folksinternally and discovered that there
were actually these two differentversions, the labs version and

(02:16):
then the official product version.
There currently is not documentationfor the product version just yet,
but I have seen the documentation.
It's just not published andavailable on the web just yet.
That should be there soon though.
And then also I wanted to note that theGoogle search currently pulls up the labs
version as the top result, but hopefullythat will also be getting solved too.

(02:38):
So just keep an eye out in the URL,
if it says something about Neo4jLabs, then that's going to be the
labs or beta version of the project.
And then if you don't see that Labsadd-on inside the URL, then it's going
to be the official product version.
So just keep an eye out for that.
I will link the official productversion, the GitHub project of the

(02:58):
product on the show notes, so takea look at that one. But the steps are
that you download the compressed filefor your specific operating system.
You will create an API key in the Auraconsole, so that does require going out
to the browser and logging into yourAura console and creating an API key.
And then you'll go back to the CLIand configure the CLI for that key.

(03:19):
And that sets you off to the races.
Again, documentation is coming.
There's a little bit of detailinside the GitHub project.
There will be more informationcoming out about that hopefully soon.
Then, I was also following up alittle bit with the Neo4j GenAI
Java library that I talked aboutexperimenting with a few weeks ago,
and I came across an issue where I wastrying to spin the project back up

(03:43):
and connect to a local instance thatI was running through Neo4j Desktop.
If you're not familiar, Neo4j Desktopis a downloadable application for your
machine that you can spin up, tear down,add plugins to local instances of Neo4j.
And I occasionally spin this up andrun it, but I kind of ran into a

(04:04):
little bit of a gotcha, not reallya bug. It's just something that I
didn't realize this is how it worked.
So, I was having trouble connectingthe application that I was
building to my Neo4j instance.
It just didn't look like it was ableto connect to the database at all.
The default connection for a Neo4jinstance running locally is localhost
port 7687, which is the bolt port.

(04:25):
I never even thought to check this.
It's always localhost 7687, right?
Well, I actually realized thatthe bolt port for this specific
Desktop instance was showing 7689.
So I had a little bit of a mild panic thatsomebody had changed the default bolt port
and kind of was figuring out what's goingon, why, where did I miss this, et cetera.

(04:49):
And I pinged some folksinternally and they're like,
don't worry, it didn't change.
But there is this little bitof a gotcha inside Desktop.
Where if you have an instance runninglocally inside Desktop and you try
to spin up a new instance while thatexisting instance is running, it
will modify the default bolt port forthat new instance and increase it.

(05:11):
So even if you shut down both instances,you go several weeks, days, months later,
and you spin only the one instance, thenewer one, back up, it still sets that
default to the higher bolt port number.
That's why it was showing the 7689.
I must have, when I created thisinstance, already had an instance
running that was using the 7687.

(05:32):
And so it set the default port tosomething higher, and I didn't realize it.
Just so you know, if you for some reasoncannot get something to connect, just
make sure your connection credentialsare actually what you expect them to be.
And I modified that within my application,changed it to the 7689 the desktop
instance was showing, and all ofa sudden everything ran fine.

(05:53):
That was the problem.
It did fix it.
So just as a heads up, if you're runninglocal instances through Neo4j Desktop,
there is a little bit of a gotcha.
Just make sure you know whatthat connection string is
before you try to use it.
The other thing I got to play withthis week using that GenAI Java library
that I've been talking about is that,as with a lot of GenAI frameworks with

(06:15):
Neo4j, you often will run the vectorsimilarity search and then you'll
run an additional retrieval query.
If you've seen LangChain or someof the other frameworks out there,
you'll typically find similar resultsto the input, which does that vector
similarity search, and then you goback out to the database and you
pull extra related information,additional context, and so on, that's

(06:36):
alongside and stored connected to
those similar results.
And the way that this GenAI librarydoes it is it uses the Cypher DSL
library, which I was really excitedabout, actually, because I've had the
Cypher DSL library on my, I guess, toplay with list for a long time now.
And I'd never reallygotten a chance to do it.
So this was my excuse to be able todive into that just a little bit.

(07:00):
I got to play with some things, ran into acouple of bumps trying to figure out which
methods and how to construct the
code, I guess, in order to callthese certain Cypher clauses
and do the filtering and things.
I found there were a few thingsthat I just felt were missing some
examples in the documentation.
I hope then that I can put togethersome content, maybe blog posts or so

(07:21):
on, kind of detailing some of thesethings and show how to use the things
that I was trying to get it to do.
But this was really fun to play with.
I'm looking forward to gettingto experiment a little bit more
with the Cypher DSL library.
The piece of content I wanted to lookat this week is actually a fun one I
came across in one of my newsletters.
It's called Flour, Water, Salt, GitHub:
The bread code is asourdough baking framework.

(07:44):
The title is actually a play on Salt, Fat,Acid, Heat, which is a Netflix series,
also a website with lots of other content.
But this article was put togethertalking about baking bread.
And baking is something that a lotof people took up in the last few
years, especially since the pandemic.
But this article's authorexpressed his frustration with

(08:05):
creating artisanal pancakes.
So every time he would try to make bread,he would end up with artisanal pancakes.
something that didn'trise and get a good crumb.
He was having trouble getting thedesired result out of the bread.
It just wouldn't be quite tallenough when it would bake.
Even after referencing a lot oftutorials, trying to find hacks,
the trouble still remained.
So this author decided there's gottabe something else, and that's when

(08:29):
he ran across a GitHub repositoryfrom a developer turned bread baker
that contains all the resources andbackground info to get good bread.
There's actually a hard copy ofthis book and a pdf download of
this Github repository as well.
It's the wonderful thing about Github
code repositories.
There's lots of differentways that you can export and
produce the content, but

(08:51):
the content is going tostart with an overview.
It digs right into the science behindthe reactions and the ingredients in
bread, talks about the inputs and outputsthat give you various things in the
chemical reactions, and it goes indepth on errors and how to debug them.
I really love this approach, not only assomeone who likes watching baking shows
and as someone who is kind of a hobbyistbaker myself, but also as a developer.

(09:15):
I've mentioned this on the show before,that devs often will copy paste code, but
we really truly master and manipulate codeinto exactly what we need by understanding
what's going on under the hood.
And with a resource likethis, we understand that bread
works the exact same way.
If you understand how the ingredientsare reacting to one another, how long to

(09:37):
let it rest, how long to knead it, howto get the chemical reactions that you're
looking for, it helps you produce theexact outputs that you want at the end.
Honestly, you don't really just have tolook at mashups of coding and baking.
You could apply this to anyskill and mash these up.
I'd love to see more mashupslike this one, honestly.
But this was a really fun, interestingone that just goes to show you that

(09:59):
the things that you learn in codingcan be applied to other topics and
other subjects and skills as well.
We covered a lot today, kicking off withlearning about the Neo4j official CLI, a
Desktop gotcha, and the Cypher DSL library.
Then we looked at an article about thebread code and how baking sourdough

(10:20):
has elements in common with coding too.
Have a wonderful weekend.
As always, thanks forlistening and happy coding.