Neo4J on foojay.io - Friends of OpenJDK

Breaktime Tech Talks (Ep39): Why embedding models should match + Advice for starting a blog

Wed, 16 Apr 2025 05:35:04 +0000

This is episode 39 of the Breaktime Tech Talks podcast .

I’m at a conference this week presenting on a variety of different topics, but I stopped for just a few minutes to document some recent learnings while I was preparing the code projects for this week’s sessions.

I’ll chat about a hands-on experience that helped me understand why embedding models for vectors and search should actually match. Then I came across an article with advice for creating a blog that outlines a lot of the practices I myself follow when I write tech blogs. I hope you enjoy it as well.

Breaktime Tech Talks (Ep37): Vector Database Frustration + Microsoft LazyGraphRAG

Wed, 19 Mar 2025 12:54:36 +0000

This is episode 37 of the Breaktime Tech Talks .

You are listening to the Breaktime Tech Talks podcast, a bite-sized tech podcast for busy developers, where we’ll briefly cover technical topics, new snippets, and more in short time blocks. I’m your host, Jennifer Reif, an avid developer and problem solver with special interest in data, learning, and all things technology.

Spring Data Neo4j: How to update an entity

Wed, 05 Feb 2025 18:58:12 +0000

After working on a new online Spring Data Neo4j course , I learned a couple more things about updating an entity.

The course required a different set of scenarios than outlined in my previous SDN update blog post , so I wanted to cover those scenarios, as well.

Spring save() method

First up is the out-of-the-box save() method that is provided by Spring as a default. This method takes an input of the entity object you want to save to the database.

Gear Up for NODES 2024: What to Know

Thu, 03 Oct 2024 17:00:46 +0000

NODES is a free, virtual conference run by Neo4j for developers, data scientists, and other technical roles who want to learn more about graph databases and how they can be used to solve complex problems. Join us online November 7!

The NODES 2024 conference is approaching fast, and we have a lot of exciting activities, including talks, workshops, and more. Here’s what you need to know to get ready for NODES 2024.

Press the Easy Button: Organize a Virtual Conference Schedule with a Graph Database

Tue, 10 Sep 2024 06:17:38 +0000

Putting together a conference schedule for NODES 2024 (one of my favorite events of the year) is a massive undertaking, but my colleague and I used technologies and tools at our disposal to make this process a little more efficient and greatly reduce opportunities for mistakes.

Every year, Neo4j hosts the virtual event NODES 2024 - a free, technical event spanning global timezones and a variety of graph-related topics. This is one of my favorite events of the year, but it doesn’t happen without countless hours of planning and work to make it valuable to the graph community.

How to Run Neo4j on Kubernetes

Tue, 25 Jun 2024 19:34:00 +0000

Kubernetes is an open-source container orchestration platform that automates the deployment, scaling, and management of containerized applications. In this post, we walk through how to run the Neo4j graph database on Kubernetes.

For an upcoming event, I was asked to give a demo of how to run Neo4j on Kubernetes. I had very little experience with Kubernetes, so I decided to document my journey for later reference.

What is Kubernetes?

Kubernetes is an open-source container orchestration platform that automates the deployment, scaling, and management of containerized applications. It was originally developed by Google and is now maintained by the Cloud Native Computing Foundation.

How to Submit a Technical Presentation

Thu, 16 May 2024 09:06:05 +0000

There is no shortage of technical events such as conferences, meetups, trainings, hackathons, and so on. These events are a great way to learn new things, connect with people, and share knowledge with others. One of the most valuable and exciting ways to share knowledge is by giving a technical presentation.

Today, we will look at how to submit a technical presentation for an event and get some personal recommendations from me, as well. Though we will specifically gear the information for the NODES 2024 call for proposals, nearly everything discussed can be applied to other technical events and speaking engagements.

Spring AI: How to Write GenAI Applications with Java

Thu, 09 May 2024 18:46:55 +0000

Generative AI (GenAI) is currently a hot topic in the tech world. It’s a subset of artificial intelligence that focuses on creating new content, such as text, images, or music. One popular type of GenAI component is the Large Language Model (LLM), which can generate human-like text based on a prompt.

Retrieval-Augmented Generation (RAG) is a technique that enhances the accuracy and reliability of generative AI models by grounding them in external knowledge sources. While most GenAI applications and related content are centered around Python and its ecosystem, what if you want to write a GenAI application in Java?

Journeys in Java, Level 10: Service Discovery with Eureka

Thu, 13 Jul 2023 06:39:06 +0000

Gaining complexity in a microservices system certainly isn’t for the faint of heart (though neither is complexity in monoliths!).

When there are many services that need to communicate with one another, we might need to coordinate multiple services communicating with multiple other services.

We also might code for varying environments such as local, development server, or the cloud.

How do services know where to find one another?
How can we avoid problems when a service is unavailable?
How do we handle requests when we scale up or down certain parts of our system?

This is where something like Spring Cloud Netflix Eureka comes into play.

Time Machine: A Look-Back at Java Sessions from NODES 2022

Wed, 28 Jun 2023 07:53:07 +0000

Figure 1. Base Photo by Compare Fibre on Unsplash

As we prepare for NODES 2023, I wanted to pull out the time machine and review the Java sessions from NODES 2022 .

I will be submitting some abstracts to the 2023 Call for Proposal here soon, likely in the Java category, so I thought looking at last year’s sessions might give me some inspiration or ideas for gaps or continuations I might want to explore.

Journeys in Java, Level 9: Docker compose all the things

Sun, 26 Feb 2023 10:02:15 +0000

Our microservices project contains quite a few pieces now.

We have two databases, three API services, a user-view service for books, and a service to host our configuration.

With so many pieces to manage, it would be nice to have something that orchestrates the individual services into a system, such as Docker Compose.

Back in our Level 5 rendition, we did exactly this for our smaller version of the project.

Now that we have expanded our services, we need to add those new pieces into the existing Docker Compose management umbrella.

Journeys in Java, Level 8: Add MongoDB to Spring Cloud Config

Thu, 09 Feb 2023 16:56:28 +0000

In our last article , we used Spring Cloud Config to provide database credentials to a microservice application connecting to a cloud-hosted Neo4j database. This post will backport this concept to our existing MongoDB database instance and its related microservices.

We will add our MongoDB credentials to the config server, so that it will be the central place for both our Neo4j and MongoDB database access. However, each service only has access to the credentials that it needs to operate, which provides some level of security through “separation of concerns” (versus universal access).

Journeys in Java, Level 7: Externalize Microservice Configuration

Mon, 30 Jan 2023 15:43:16 +0000

Our decided next step for this project takes us in a new direction by adding externalized configuration for our applications.

We already saw how to do something similar with MongoDB database credentials in Docker Compose to access a local database container, but what do we do when the database is hosted on public cloud or contains sensitive data?

We probably don’t want to publish our credentials anywhere or even prevent accidental publishing.

Faster Integration Tests with Reusable Testcontainers

Wed, 17 Aug 2022 11:05:05 +0000

In my job, I often need integration tests against a Neo4j database. My software is written in Java, and so is Neo4j. Neo4j is embeddable, too. So, in theory, I could just depend on the embedded version, open a connection, test my stuff and call it a day. It would not be a different engine, it would be - at least from a query-engine and planer perspective - the same thing, in contrast to using an embedded SQL database as a drop-in for PostgresQL for example.

Native GraphQL API with Neo4j AuraDB on Heroku

Mon, 08 Aug 2022 07:29:38 +0000

In my first article on Foojay, I would like to present one of many possible approaches to create a GraphQL API. I work at Neo4j , so it should not be a big suprise that I will use the Graph database with the same name as a backend for the application.

In this post I will cover a couple of things and I’ll start with a simple use case. Conceptually we will look at the “Schema-First” vs “Object-First” discussions and why - at least in my opinion - GraphQL can be seen much more like an object mapping concept than a query language itself. You will learn that while Neo4j is a Graph database, it does not have a built-in GraphQL layer. It does however a great query language called “Cypher” .

Journeys in Java, Level 6: Build a Neo4j Microservice

Wed, 13 Jul 2022 15:13:43 +0000

For our next adventure in Java microservices, we want to expand our system for book review data.

While books and authors are well-suited for a document database such as MongoDB, once you add reviews to the mix, the importance of the relationships makes this project better suited for a graph database.

This way, we can utilize relationships between the different entities to improve analysis based on the structure of the connections.

Journeys in Java, Level 5: Building an Empire of Microservices

Thu, 02 Jun 2022 05:08:28 +0000

We continue building our microservices system by adding a coordination layer to handle spinning multiple services up and down.

In previous articles, we grew from two Spring Boot applications to three applications + a database container.

As we continue to scale and broaden our system, we will need something to coordinate service and ensure consistent communication (avoid human error).

We will do this through docker-compose , an orchestration tool that manages containerized applications.

Journeys in Java, Level 4: Building an Empire of Microservices

Wed, 27 Apr 2022 07:22:03 +0000

This article is the fourth iteration in a series of posts about building microservices in Java.

The initial post started with a single string message passed between two locally-running applications, and we are gradually adding services and functionality along the way.

In this level 4 instalment, we will add a new service that will manage book authors. It will call a database containing a data domain of books and retrieve authors and their information. This will entail creating a new, separate service from our previously written service1 and service2.

Fullstack IMDB Clone with a Java Backend using SparkJava and Neo4j

Wed, 20 Apr 2022 07:11:02 +0000

Our GraphAcademy is teaching folks starting out in the graph space the fundamentals of the data model, query language, and graph algorithms.

And for developers, there are courses for using our drivers and building the backend of a fullstack app in JavaScript, Go, Python, Java, and soon .Net.

The application is an IMDB clone based on the MovieLens recommendation dataset augmented with movie and cast data from themoviedb.org .

The front-end is written in vue.js and looks pretty slick.

Visualization of Business Function Message Flow with Vaadin and Neo4j

Wed, 16 Mar 2022 08:21:10 +0000

The Project

Analyzing and visualizing the message flow between business functions was the goal of my current project. At first we considered using a UML tool for this job, but we came to the conclusion that it might not be as flexible as we need it to be. Finally I’ve got the assigment to create a custom web application.

Since business functions and messages are related to each other, it made sense to represent them as a graph. That’s why I chose Neo4j as the database. Now the question was how to manage and visualize the graph. As I’m expierenced with the Vaadin framework I want to use it also in this project.

Journeys in Java, Level 3: Building an Empire of Microservices

Fri, 04 Mar 2022 16:23:40 +0000

We are still in the beginning stages of building microservices with Java, but we have already seen how to send and receive communications between two Spring Boot applications. In the first blog post of this series, our two applications transmitted a message string of "Hello, World!". In the second blog post , we took it one step further by embedding a MongoDB database into our service1, added a data domain (books) with four pre-populated entries, and transmitted the Book information between the two applications.

Hand Ground Coffee: Command Line Tools for Java

Mon, 21 Feb 2022 16:04:15 +0000

In the book “97 Things every Java Programmer should know ” (I contributed 2 of the 97 tips) there is a chapter about some command line tools in the JDK.

Since I make heavy use of such helpers myself, I wanted to briefly introduce them in today’s article.

Personally I prefer the command line for my daily work, using the combination of git, sed, grep, bash commands etc. makes recurring tasks easier.

Journeys in Java, Level 2: Building an Empire of Microservices

Wed, 16 Feb 2022 15:29:33 +0000

Let’s dive into the world of microservices find out the complexities, best practices, and troubles. I will share all my learnings, as well!

In my last blog post , we began building microservices in Java with two Spring Boot applications, passing a “Hello, World!” string from one application to the other. We focused on reduced complexity, minimum previous knowledge, and few components. Next, we can slowly add pieces that simulate microservices projects in the real world.

Journeys in Java, Level 1: Building an Empire of Microservices

Fri, 28 Jan 2022 14:21:37 +0000

Microservices have been used and deployed in businesses and projects for awhile, and there is plenty of content available for architecting them into a system. For my next project, I want to dive into the world of microservices and begin building my own little virtual empire from different kinds of services to find out the complexities, best practices, power, and trouble that comes with them. I will share all my learnings along the way, as well.