Import data

Step 1: Prepare your movie dataset

Your data needs information about movies, actors, and their relationships. The CSV file contains this information in a tabular format that we’ll transform into a graph. Proper data preparation ensures a smooth import and an effective graph model.

How to prepare your data before importing:

Data preparation checklist:

Before importing, verify your CSV data:

What’s in the dataset: This CSV contains information about movies and the actors who appeared in them. Each row represents an actor’s role in a movie, which we’ll model as a relationship in the graph. This structure enables recommendation queries like "Find all movies with Tom Hanks" or "Find actors who worked together."

Example data structure:

movieId,title,personId,name,characters
123,The Matrix,456,Keanu Reeves,"Neo"
123,The Matrix,789,Laurence Fishburne,"Morpheus"

This structure shows that both Keanu Reeves and Laurence Fishburne acted in The Matrix, creating two ACTED_IN relationships in your graph.

Step 2: Add your data source to Aura

How to do it:

CSV files are easy to work with and commonly used for data imports. The Data Importer reads the CSV structure and helps you map it to graph nodes and relationships.

Step 3: Review your data structure

Once the file is uploaded, you’ll see the Data Importer interface showing your CSV structure.

The Data Importer displays your CSV columns (movieId, title, personId, name, characters) and sample data rows. This preview helps you understand what data you’re working with before creating your graph model.

Step 4: Create your data model

The data model defines how your CSV data becomes a graph. You need: * Movie nodes - Each movie becomes a node to query * Person nodes - Each actor becomes a node to traverse from * ACTED_IN relationships - These connections enable recommendation queries like "Find movies with the same actors"

How to do it: Click Create model manually to start building your graph structure.

Understanding nodes and relationships in context

How this relates to Neo4j Fundamentals:

If you’ve taken the Neo4j Fundamentals course, you learned that graphs consist of: * Nodes (vertices) - Entities in your domain (like movies and actors) * Relationships (edges) - Connections between entities (like ACTED_IN) * Properties - Attributes stored on nodes and relationships (like title on Movie nodes, characters on ACTED_IN relationships) * Labels - Categories for nodes (like Movie and Person)

In this import, you’re creating these graph elements from your CSV data: * Each unique movie becomes a Movie node with a title property * Each unique actor becomes a Person node with a name property * Each actor-movie pair becomes an ACTED_IN relationship with a characters property

How this relates to Graph Data Modeling Fundamentals:

If you’ve taken the Graph Data Modeling Fundamentals course, you learned about: * Instance models - The actual nodes and relationships in your graph (what you’re creating now) * Domain models - The conceptual design of your graph (Movie and Person connected by ACTED_IN)

The Data Importer helps you create an instance model from your CSV. You’re deciding: * Which entities become nodes (Movie, Person) * Which connections become relationships (ACTED_IN) * Which CSV columns become properties (title, name, characters)

This modeling step is critical—a well-designed model makes recommendation queries fast and intuitive.

How this relates to Importing Data Fundamentals:

If you’ve taken the Importing Data Fundamentals course, you learned about: * Import methods - Different ways to load data (Data Importer, LOAD CSV, neo4j-admin import) * Data transformation - Converting tabular data (CSV) into graph structures (nodes and relationships) * Unique constraints - Ensuring nodes aren’t duplicated (using movieId and personId as unique identifiers)

In this lesson, you’re using the Data Importer (a visual, no-code tool) to transform your CSV into a graph. The Data Importer automatically handles: * Creating unique nodes (using movieId and personId as keys) * Mapping CSV columns to node and relationship properties * Generating efficient Cypher statements for the import

Key takeaway: Nodes and relationships are the building blocks you learned about in Neo4j Fundamentals. The modeling principles from Modeling Fundamentals guide how you structure them. The import techniques from Importing Fundamentals show you how to create them from your data. This lesson combines all three—you’re applying fundamentals to build your recommendation engine.

Step 5: Define Movie nodes

Movies are central to your data model. Each Movie node has properties (title, movieId) to use in queries like "Find movies similar to The Matrix."

How to do it:

How it works in the background: When you map movieId and title, the Data Importer will create Cypher statements like:

CREATE (m:Movie {movieId: '123', title: 'The Matrix'})

This creates Movie nodes that your recommendation queries can traverse.

After adding the label, you can edit the model structure to refine how your CSV data maps to graph elements.

Step 6: Define Person nodes

Actors are the connections between movies in your data model. When you query "Find movies with Tom Hanks," you’re traversing from a Person node through ACTED_IN relationships to Movie nodes.

How to do it:

Example for recommendations: Once imported, you’ll be able to query:

MATCH (p:Person {name: 'Tom Hanks'})-[:ACTED_IN]->(m:Movie)
RETURN m.title

This finds all movies Tom Hanks acted in—the foundation of actor-based recommendations.

Optional: Edit property types by clicking the pencil icon next to each property. For example, you might want to ensure personId is stored as an integer for better query performance.

Step 7: Define ACTED_IN relationships

Relationships are the core of your graph. The ACTED_IN relationship connects Person nodes to Movie nodes, enabling queries like: * "Find all movies with the same actors" (traverse from Movie through ACTED_IN to Person, then back to other Movies) * "Find actors who worked together" (find two Person nodes connected to the same Movie)

How to do it:

How it works in the background: The Data Importer creates Cypher statements like:

MATCH (p:Person {personId: '123'}), (m:Movie {movieId: '456'})
CREATE (p)-[:ACTED_IN {characters: ['Neo']}]->(m)

This creates the connections your recommendation engine needs to traverse.

Verification: The green checkmark indicates that the relationship mapping is correct. Your model now shows Person nodes connected to Movie nodes via ACTED_IN relationships—exactly what you need for recommendation queries.

Step 8: Review and confirm your model

Before importing, verify that your model correctly maps CSV data to graph structure. Incorrect mappings mean your queries won’t work.

How to do it:

How it works in the background: The Data Importer analyzes your CSV to ensure: * No duplicate nodes (uses movieId/personId as unique keys) * All relationships can be created (both Person and Movie nodes exist) * Data types are correct (strings, numbers, etc.)

Step 9: Run the import

How to do it:

How it works in the background: The Data Importer: 1. Generates optimized Cypher statements from your model 2. Connects to your Aura instance 3. Executes batched inserts (creates nodes first, then relationships) 4. Verifies all data was imported correctly 5. Reports any errors or warnings

The Data Importer processes your CSV data and creates nodes and relationships in your Neo4j instance. After the import completes, you’ll see a summary of what was created.

Step 10: Verify your import results

What to check: The import summary shows how many nodes and relationships were created. For your recommendation engine, you should see: * Multiple Movie nodes (one for each unique movie) * Multiple Person nodes (one for each unique actor) * ACTED_IN relationships connecting them

If the counts look correct, your data was imported successfully. If something seems off (e.g., zero relationships), your model mapping might need adjustment.

Example: A successful import might show: * 100 Movie nodes * 50 Person nodes * 200 ACTED_IN relationships

This means you have 200 actor-movie connections to traverse for recommendations.

Step 11: Save your data model

If you need to import more data later or recreate the structure in another instance, the saved model lets you reuse the same mapping without rebuilding it.

How to do it:

Reusing the model: Load this model later and apply it to new CSV files with the same structure, making it easy to add more movies to your recommendation engine.