Jennifer Reif on foojay.io - Friends of OpenJDK

Foojay Podcast #100: Java Podcasters on Why They Started, What Broke, and What They Learned

Mon, 13 Jul 2026 07:05:59 +0000

Foojay Podcast hits episode 100. No plan, no roadmap. It just happened. To mark the occasion, Frank turned the microphone around and invited other podcasters: Adam Bien (airhacks.fm), Jennifer Reif (Breaktime Tech Talks), Kadi McKean and Steve Pool (10xInsights), and Oumaima Zerouali (JCast). Same three questions for each: why did you start, what broke, and what did you learn?

YouTube

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

Intro to RAG: Foundations of Retrieval Augmented Generation, part 2

Tue, 10 Jun 2025 21:54:49 +0000

In the last post , we discussed the basics of Retrieval Augmented Generation (RAG) and how it enhances the capabilities of Large Language Models (LLMs) by integrating them with external knowledge sources. We also introduced the concept of vector embeddings and their role in semantic search.

In this post, we’ll dive deeper into the different layers of RAG, including vector RAG, graph RAG, and agents. We’ll explore how these layers can be combined to create more powerful and effective AI systems.

Intro to RAG: Foundations of Retrieval Augmented Generation, part 1

Tue, 27 May 2025 14:42:43 +0000

Retrieval Augmented Generation (RAG) may sound complex, but it accurately represents the process of the system. RAG is a method that enhances the capabilities of Large Language Models (LLMs) by integrating them with external knowledge sources.

Each term represents a piece of the puzzle:

Retrieval - data retrieved from some external source outside the LLM (most often a database, but can include files, webpages, etc)
Augmented - “augmenting” (or adding to) an LLM’s training data. This could include recent or private information that it did not have access to during its training period. Most often, this is done by adding the data to the prompt (or input) to the LLM.
Generation - this is where LLMs are exceptional. They generate a response (text, image, video, etc) that is similar to the data being provided in the input. This is generated from probabilities, so cannot guarantee 100% consistency.

Instead of relying solely on the model’s internal training data, RAG retrieves relevant information from databases or document collections to ground its responses in factual and up-to-date content. This approach not only improves the accuracy and reliability of the generated outputs but also allows the system to adapt to specific contexts or domains, making it a powerful tool for many personal and professional applications.

GenAI blood, sweat, and tears: Loading data to Pinecone

Wed, 07 May 2025 22:10:37 +0000

As someone who is pretty familiar with relational and graph databases, I wanted to dig a little deeper into vector databases and understand the strengths and quirks they bring to the database table. I put together a conference abstract on vector RAG versus GraphRAG which got picked up, so I went to work building a demo and learning all I could.

I pivoted a few times along the way, but ended up with a Spring AI application that connects to both Pinecone (vector database) and Neo4j (graph database). There were a few surprises throughout, which I’ll be sure to mention. Let’s get started!

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.

Spring AI Debugging + How to Contribute to Open Source

Wed, 02 Apr 2025 05:56:01 +0000

In this episode, I continue my journey with vector databases, integrating Pinecone , Neo4J , and Spring AI . While making some progress, I also encountered hurdles, such as evolving APIs and the unique architecture of vector stores.

Next, I share insights from an article on contributing to open-source source projects , how it can accelerate your career and enhance both your technical and soft skills. From picking the right project to building credibility within the community, it’s a series of steps that gets better with time and practice!

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?

Create a Spring Boot Application to Retrieve Data from Evernote

Mon, 28 Aug 2023 11:06:45 +0000

I recently started work on a joint project with my colleague, Jason Koo . For this project, we want to import data from second brain apps (such as Obsidian, Notion, Evernote, etc) to Neo4j.

Since I use Evernote, I was tasked with getting my notes out of Evernote.

In this article, I will show you how to use the Evernote API and SDK in a Spring Boot application to retrieve data from Evernote.

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.

Neo4j's Online Conference Is Coming In October...

Wed, 07 Jun 2023 08:46:15 +0000

NODES is back for its fifth year on October 26, 2023!

It’s the biggest graph community gathering dedicated to learning how to integrate graph technologies into ML and dev projects.

For 24 hours nonstop, speakers from around the world will showcase their implementations, tools, models, and more – sharing everything they’ve learned over this past year.

Join thousands of fellow developers, data scientists, and data engineers to get firsthand knowledge from peers who will show you the ropes – for free! So be sure to save your seat !

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.

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.

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.

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.