Introducing Neo4j 5: Unbounded Scale, Performance, and Agility | Learn More
The Neo4j Graph Platform – The #1 Platform for Connected Data Menu
The Neo4j Graph Platform – The #1 Platform for Connected Data Close

Plateforme de données de graphes Neo4j

Des graphes ultra-rapides, à l’échelle du pétaoctet

En dépassant le millier de milliards d’entités, Neo4j à la préférence des développeurs, des data scientists et des entreprises qui font confiance à ses performances, son analytique évolutive, son développement applicatif intelligent et ses pipelines avancés d’intelligence artificielle et de machine learning.

La plateforme de données de graphes adaptée aux applications intelligentes d’aujourd’hui

Grâce à sa base de données de graphes native, Neo4j stocke et gère les données dans leur état connecté le plus naturel. En s’appuyant sur leurs relations, la plateforme permet une exécution des requêtes ultra rapide, approfondit le contexte à des fins d’analytique et offre un modèle de données modifiable en toute facilité.

LE LEADER DE LA TECHNOLOGIE DES GRAPHES

Performance, fiabilité et intégrité incomparables

Créateur et leader du secteur des bases de données de graphes, Neo4j continue de repousser les limites de cette technologie. La plateforme vise à offrir à sa communauté active de 220 000 développeurs, data scientists et architectes, les moyens de résoudre des problèmes de données majeurs du monde actuel.

INNOVATION & MACHINE LEARNING

Apporter du contexte pour en tirer des enseignements approfondis

Les analystes et data scientists peuvent incorporer des structures de réseau pour donner du sens à leur données, rendre le machine learning plus précis et favoriser l’intelligence artificielle contextuelle, avec à la clé de meilleures prédictions à partir des données déjà en leur possession.

Neo4j fonctionne avec une vaste bibliothèque d’algorithmes prêts pour la production et des flux de machine learning avancés et innovants, introuvables par ailleurs.

En savoir plus sur la Graph Data Science

UNE PERFORMANCE À TOUTE ÉPREUVE

La plus fiable. La plus sécurisée. La plus déployée.

Dans sa version entreprise, Neo4j est la seule base de données de graphes à associer le stockage natif des graphes, la sécurité avancée, l’architecture évolutive optimisée pour la vitesse et la conformité ACID. L’objectif : garantir la capacité de prédiction et l’intégrité des requêtes basées sur les relations. Autant de raisons pour lesquelles des centaines d’entreprises du Fortune 500, d’organismes publics et d’ONG l’ont déjà déployée.

handshake, nodes and database

NEO4J DANS LE CLOUD

Neo4j Aura : le service cloud entièrement géré

"Neo4j Aura est une plateforme rapide, évolutive, toujours disponible et entièrement automatisée, proposée sous forme de service cloud. Grâce à elle, vous consacrez votre temps à innover plutôt qu’à gérer l’infrastructure.

Neo4j Aura inclut AuraDB, une base de données de graphes cloud pour les développeurs d'applications intelligentes. La solution comprend aussi AuraDS, une plateforme de science des données de graphes (graph data science), elle aussi entièrement gérée, destinée aux data scientists qui élaborent des modèles prédictifs et des workflows analytiques."

En savoir plus
Provisionnements, mises à niveau et sauvegardes entièrement automatisés
Disponibilité permanente, sécurité, fiabilité et conformité ACID
Évolutivité à la demande, sans temps d’arrêt
Tarification simple, basée sur la consommation
cloud and database

CYPHER : LE LANGAGE DE REQUETE DE GRAPHES

Oubliez les jointures complexes

Optimisé pour les graphes, Cypher est un langage de requête puissant et intuitif qui comprend et exploite les connexions entre les données. Accessible et facile à maîtriser, il suit les connexions — quelle que soit leur direction — pour révéler des relations et des clusters jusqu’alors invisibles.

Lorsqu’il s’agit de trouver des schémas dans les données ou d’en tirer des enseignements, les requêtes Cypher sont bien plus simples à écrire qu’une multitude de jointures SQL. Inutile de se préoccuper des jointures dans Neo4j, car il n’y a pas de tables. Vous pouvez comparer ci-contre la requête Cypher et son équivalent en SQL.

En savoir plus sur Cypher
Cypher
MATCH (p:Product)-[:CATEGORY]->(l:ProductCategory)-[:PARENT*0..]->(:ProductCategory {name:"Dairy Products"})
RETURN p.name
SQL
SELECT p.ProductName
FROM Product AS p
JOIN ProductCategory pc ON (p.CategoryID = pc.CategoryID AND pc.CategoryName = "Dairy Products")

JOIN ProductCategory pc1 ON (p.CategoryID = pc1.CategoryID)
JOIN ProductCategory pc2 ON (pc1.ParentID = pc2.CategoryID AND pc2.CategoryName = "Dairy Products")

JOIN ProductCategory pc3 ON (p.CategoryID = pc3.CategoryID)
JOIN ProductCategory pc4 ON (pc3.ParentID = pc4.CategoryID)
JOIN ProductCategory pc5 ON (pc4.ParentID = pc5.CategoryID AND pc5.CategoryName = "Dairy Products");

Utilisez vos langages de programmation préférés

Nous souhaitons offrir aux développeurs une expérience de Neo4j rapide, facile et plaisante. C'est pourquoi Neo4j prend en charge GraphQL et les drivers .Net, Java, Node.js, Python, etc. Notre communauté de contributeurs fournit par ailleurs bien d’autres drivers, comme PHP, Ruby, R, Erlang et Clojure.

En savoir plus sur les drivers
// npm install --save neo4j-driver
// node example.js
const neo4j = require("neo4j-driver");
const driver = neo4j.driver("bolt://<HOST>:<BOLTPORT>", neo4j.auth.basic("<USERNAME>", "<PASSWORD>"), {
	/* encrypted: 'ENCRYPTION_OFF' */
});

const query = `
  MATCH (p:Product)-[:PART_OF]->(:Category)-[:PARENT*0..]->
  (:Category {categoryName:$category})
  RETURN p.productName as product
  `;

const params = { category: "Dairy Products" };

const session = driver.session({ database: "neo4j" });

session
	.run(query, params)
	.then((result) => {
		result.records.forEach((record) => {
			console.log(record.get("product"));
		});
		session.close();
		driver.close();
	})
	.catch((error) => {
		console.error(error);
	});
# pip3 install neo4j-driver
# python3 example.py

from neo4j import GraphDatabase, basic_auth

driver = GraphDatabase.driver(
  "bolt://<HOST>:<BOLTPORT>", 
  auth=basic_auth("<USERNAME>", "<PASSWORD>"))

cypher_query = '''
MATCH (p:Product)-[:PART_OF]->(:Category)-[:PARENT*0..]->
(:Category {categoryName:$category})
RETURN p.productName as product
'''

with driver.session(database="neo4j") as session:
  results = session.read_transaction(
    lambda tx: tx.run(cypher_query,
      category="Dairy Products").data())

  for record in results:
    print(record['product'])

driver.close()
// go mod init main
// go run example.go
package main
import (
	"fmt"
	"github.com/neo4j/neo4j-go-driver/neo4j" //Go 1.8
)
func main() {
	s, err := runQuery("bolt://<HOST>:<BOLTPORT>", "<USERNAME>", "<PASSWORD>")
	if err != nil {
		panic(err)
	}
	fmt.Println(s)
}
func runQuery(uri, username, password string) ([]string, error) {
	configForNeo4j4 := func(conf *neo4j.Config) { conf.Encrypted = false }
	driver, err := neo4j.NewDriver(uri, neo4j.BasicAuth(username, password, ""), configForNeo4j4)
	if err != nil {
		return nil, err
	}
	defer driver.Close()
	sessionConfig := neo4j.SessionConfig{AccessMode: neo4j.AccessModeRead, DatabaseName: "neo4j"}
	session, err := driver.NewSession(sessionConfig)
	if err != nil {
		return nil, err
	}
	defer session.Close()
	results, err := session.ReadTransaction(func(transaction neo4j.Transaction) (interface{}, error) {
		result, err := transaction.Run(
			`
			MATCH (p:Product)-[:PART_OF]->(:Category)-[:PARENT*0..]->
			(:Category {categoryName:$category})
			RETURN p.productName as product
			`, map[string]interface{}{
				"category": "Dairy Products",
			})
		if err != nil {
			return nil, err
		}
		var arr []string
		for result.Next() {
			value, found := result.Record().Get("product")
			if found {
			  arr = append(arr, value.(string))
			}
		}
		if err = result.Err(); err != nil {
			return nil, err
		}
		return arr, nil
	})
	if err != nil {
		return nil, err
	}
	return results.([]string), err
}
// Add your the driver dependency to your pom.xml build.gradle etc.
// Java Driver Dependency: http://search.maven.org/#artifactdetails|org.neo4j.driver|neo4j-java-driver|4.0.1|jar
// Reactive Streams http://search.maven.org/#artifactdetails|org.reactivestreams|reactive-streams|1.0.3|jar
// download jars into current directory
// java -cp "*" Example.java

import org.neo4j.driver.*;
import static org.neo4j.driver.Values.parameters;

public class Example {

  public static void main(String...args) {

    Driver driver = GraphDatabase.driver("bolt://<HOST>:<BOLTPORT>",
              AuthTokens.basic("<USERNAME>","<PASSWORD>"));

    try (Session session = driver.session(SessionConfig.forDatabase("neo4j"))) {

      String cypherQuery =
        "MATCH (p:Product)-[:PART_OF]->(:Category)-[:PARENT*0..]->" +
        "(:Category {categoryName:$category})" +
        "RETURN p.productName as product";

      var result = session.readTransaction(
        tx -> tx.run(cypherQuery, 
                parameters("category","Dairy Products"))
            .list());

      for (Record record : result) {
        System.out.println(record.get("product").asString());
      }
    }
    driver.close();
  }
}

Outils pratiques pour développer des applications et sites web modernes

Neo4j offre une gamme d’outils, de bibliothèques et de frameworks qui accélèrent et simplifient le développement. Grâce à des outils comme Neo4j Desktop, Browser et Sandbox, les développeurs peuvent développer des applications de graphes en toute simplicité.

Et pour que les utilisateurs de GraphQL puissent se servir facilement de Neo4j, la nouvelle bibliothèque Neo4j GraphQL traduit les requêtes GraphQL en langage Cypher. Enfin, la plateforme rationalise l’intégration de Neo4j avec React, Vue et d’autres frameworks open source.

Neo4j Desktop
Pour la gestion des bases de données locales
Télécharger Desktop
Bibliothèque GraphQL
Pour des applications modernes basées sur les API
En savoir plus
Neo4j Browser
Accéder à votre base de données n’importe où
Se lancer
Prêt à découvrir Neo4j ?

Lancez-vous gratuitement avec AuraDB