{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"pypi_pypi-neo4j","slug":"pypi-neo4j","name":"neo4j","type":"framework","url":"https://pypi.org/project/neo4j/","page_url":"https://unfragile.ai/pypi-neo4j","categories":["data-pipelines","app-builders"],"tags":["neo4j","graph","database"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"pypi_pypi-neo4j__cap_0","uri":"capability://tool.use.integration.bolt.protocol.binary.communication.with.neo4j.servers","name":"bolt protocol binary communication with neo4j servers","description":"Implements the Bolt protocol (versions 4.4, 5.0-5.8, 6.0) for efficient binary communication with Neo4j graph databases, handling PackStream serialization/deserialization of queries and results. The driver uses a connection pool architecture that manages persistent TCP connections, with optional Rust-backed acceleration via neo4j-rust-ext for 40-60% faster serialization throughput. Protocol negotiation occurs at connection handshake to select the highest mutually-supported version.","intents":["I need to connect to a Neo4j database from Python with minimal latency","I want to send Cypher queries over a binary protocol instead of HTTP for better performance","I need to ensure my driver supports the latest Neo4j server versions with protocol version negotiation"],"best_for":["Python backend developers building production Neo4j applications","Teams requiring high-throughput graph database operations","Applications where HTTP overhead is unacceptable"],"limitations":["Bolt 4.0-4.1 support has been dropped; requires Bolt 4.4 or higher","Optional Rust extension (neo4j-rust-ext) must be manually installed for acceleration; not included by default","PackStream serialization adds ~5-15ms per round-trip even with Rust acceleration"],"requires":["Python 3.10 through 3.14","Neo4j server 4.4+ with Bolt protocol support","Network connectivity to Neo4j server on Bolt port (default 7687)"],"input_types":["Cypher query strings","Query parameters (dict)","Connection URI (bolt://, bolt+s://, bolt+ssc://)"],"output_types":["Query results (records)","Result summaries (metadata, statistics)","Connection state information"],"categories":["tool-use-integration","database-driver"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-neo4j__cap_1","uri":"capability://tool.use.integration.synchronous.and.asynchronous.dual.api.driver.instantiation","name":"synchronous and asynchronous dual-api driver instantiation","description":"Provides two parallel driver implementations (sync via _sync/driver.py and async via _async/driver.py) selected via GraphDatabase and AsyncGraphDatabase factory classes. URI scheme determines driver class instantiation: bolt:// and bolt+s:// route to BoltDriver or BoltAsyncDriver, while neo4j:// and neo4j+s:// route to RoutingDriver or RoutingAsyncDriver for cluster routing. Both APIs expose identical method signatures for session creation and configuration, enabling code portability between sync and async contexts.","intents":["I want to use async/await patterns with Neo4j without rewriting my entire codebase","I need to choose between sync and async APIs at driver instantiation time based on my application architecture","I want identical APIs for both synchronous and asynchronous database operations"],"best_for":["Async-first Python applications (FastAPI, aiohttp, asyncio frameworks)","Synchronous applications requiring blocking database calls","Teams maintaining both sync and async codebases with shared logic"],"limitations":["Async driver requires Python 3.10+ with full asyncio event loop support","Code must be fully async or fully sync; mixing sync and async drivers in same thread causes deadlocks","Async driver adds ~2-5ms overhead per context switch compared to pure sync"],"requires":["Python 3.10+ for async driver, Python 3.10+ for sync driver","asyncio event loop running (for async driver only)","URI with scheme: bolt://, bolt+s://, neo4j://, or neo4j+s://"],"input_types":["Connection URI string","Driver configuration dict","Authentication credentials"],"output_types":["Driver instance (BoltDriver, BoltAsyncDriver, RoutingDriver, RoutingAsyncDriver)","Session objects (sync or async)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-neo4j__cap_10","uri":"capability://safety.moderation.query.result.notifications.and.deprecation.warnings","name":"query result notifications and deprecation warnings","description":"Captures server-side notifications (warnings, deprecations, performance hints) returned with query results and exposes them via Result.summary().notifications. Notifications include severity levels (WARNING, INFORMATION) and codes (e.g., DEPRECATED_PROCEDURE, PERFORMANCE_HINT). The driver supports notification filtering via NotificationFilter to suppress or promote specific notification types. Notifications are useful for identifying deprecated Cypher syntax, performance issues, and server-side warnings without parsing error messages.","intents":["I want to detect deprecated Cypher syntax before it breaks in future Neo4j versions","I need to identify performance issues (missing indexes, inefficient queries) from server-side hints","I want to suppress or promote specific notification types for monitoring"],"best_for":["Development and testing environments for early deprecation detection","Monitoring and observability systems tracking query health","Applications with strict deprecation policies"],"limitations":["Notifications are server-side only; client-side query analysis is not performed","Notification filtering requires explicit NotificationFilter configuration; no default filtering","Some notifications may be noisy in high-volume query environments; filtering is recommended"],"requires":["Neo4j 4.0+ with notification support","Query execution returning Result object","Access to Result.summary().notifications"],"input_types":["Query results from session.run()","NotificationFilter configuration (optional)"],"output_types":["Notification objects (code, severity, message)","Filtered notification list"],"categories":["safety-moderation","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-neo4j__cap_11","uri":"capability://automation.workflow.asynchronous.transaction.and.result.streaming.with.async.await","name":"asynchronous transaction and result streaming with async/await","description":"Provides fully asynchronous transaction and result APIs using Python's async/await syntax. AsyncDriver and AsyncSession implement the same transaction patterns as sync counterparts but return coroutines. Result streaming is asynchronous via async for loops, with lazy evaluation of records. The driver uses asyncio event loop for connection management and query execution, supporting concurrent queries across multiple sessions without thread overhead. Async transactions support the same retry logic and causal consistency as sync transactions.","intents":["I want to execute Neo4j queries concurrently using async/await without thread overhead","I need to stream large result sets asynchronously without blocking the event loop","I want to integrate Neo4j with async frameworks (FastAPI, aiohttp, asyncio)"],"best_for":["Async-first web frameworks (FastAPI, Starlette, aiohttp)","High-concurrency applications (1000+ concurrent requests)","Serverless/FaaS environments with event-driven architecture"],"limitations":["Async driver requires Python 3.10+ with full asyncio support","Mixing sync and async drivers in same thread causes deadlocks; must use separate event loops","Async context switching adds ~2-5ms overhead per query compared to pure sync"],"requires":["Python 3.10+","asyncio event loop running","AsyncGraphDatabase factory for driver instantiation","async/await syntax in application code"],"input_types":["Cypher query strings","Query parameters (dict)","Transaction configuration"],"output_types":["Coroutines returning Result objects","Async iterables for record streaming","Transaction metadata"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-neo4j__cap_12","uri":"capability://data.processing.analysis.graph.type.deserialization.with.node.relationship.and.path.objects","name":"graph type deserialization with node, relationship, and path objects","description":"Automatically deserializes Neo4j graph types (Node, Relationship, Path) to Python objects with attribute access and traversal methods. Nodes expose properties as dict-like attributes and support identity/label access. Relationships expose start/end node references and properties. Paths represent traversals as sequences of alternating nodes and relationships, supporting path length and segment iteration. Graph objects are immutable and support equality comparison. The driver handles circular references and nested graph structures transparently.","intents":["I want to work with Neo4j nodes and relationships as Python objects with property access","I need to traverse paths returned from graph queries without manual parsing","I want to access node labels and relationship types programmatically"],"best_for":["Graph analysis applications working with nodes, relationships, and paths","Knowledge graph applications requiring traversal and property access","Applications building graph visualizations from query results"],"limitations":["Graph objects are immutable; modifications require re-querying and updating in Neo4j","Circular references in paths are supported but require careful iteration to avoid infinite loops","No built-in graph algorithms; path analysis requires manual traversal"],"requires":["Query results containing Node, Relationship, or Path objects","Active session for result deserialization"],"input_types":["Neo4j Node, Relationship, Path types from query results"],"output_types":["Python Node objects (with properties, labels, identity)","Python Relationship objects (with properties, start/end nodes, type)","Python Path objects (with nodes, relationships, length)"],"categories":["data-processing-analysis","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-neo4j__cap_13","uri":"capability://data.processing.analysis.vector.type.support.for.embedding.storage.and.retrieval","name":"vector type support for embedding storage and retrieval","description":"Supports Neo4j vector types for storing and retrieving embeddings (dense vectors of floats). Vectors are automatically serialized/deserialized as Python lists or numpy arrays. The driver integrates with Neo4j's vector index capabilities for similarity search without external vector databases. Vector operations (dot product, cosine similarity) are performed server-side via Cypher queries. The driver handles vector type validation and dimension checking.","intents":["I want to store and retrieve embeddings in Neo4j without external vector databases","I need to perform similarity search on embeddings using Neo4j vector indexes","I want to work with embeddings as native Python lists or numpy arrays"],"best_for":["AI/ML applications using embeddings for semantic search","Knowledge graphs with embedding-based similarity","Applications avoiding external vector database dependencies"],"limitations":["Vector indexes require Neo4j 5.0+ with vector index support","Vector similarity search performance depends on index configuration; large vectors (>1000 dimensions) may be slow","Vector operations are server-side only; client-side vector math is not supported"],"requires":["Neo4j 5.0+ with vector type support","Vector index created on Neo4j server","Query results containing vector types"],"input_types":["Python lists or numpy arrays (for vector values)","Vector dimension specification"],"output_types":["Vector objects (deserialized as lists or numpy arrays)","Similarity search results with scores"],"categories":["data-processing-analysis","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-neo4j__cap_14","uri":"capability://tool.use.integration.configuration.and.customization.via.driver.options","name":"configuration and customization via driver options","description":"Provides extensive driver configuration via GraphDatabase.driver() options including connection timeout, pool size, encryption, authentication, retry policy, and notification filtering. Configuration is immutable after driver instantiation. The driver supports environment variable overrides for sensitive settings (e.g., NEO4J_PASSWORD). Session-level configuration includes access mode, database selection, and bookmark passing. Advanced options include custom resolver for DNS resolution and custom trust store for certificate validation.","intents":["I want to configure connection timeout, pool size, and encryption for my deployment","I need to use environment variables for sensitive credentials without hardcoding","I want to customize DNS resolution or certificate validation for special network environments"],"best_for":["Production deployments requiring fine-grained configuration","Containerized/cloud environments using environment variables","Enterprise networks with custom DNS or certificate requirements"],"limitations":["Configuration is immutable after driver instantiation; changes require driver restart","Environment variable overrides are limited to specific settings; not all options support env vars","Custom resolver/trust store requires implementing specific interfaces; no pre-built integrations"],"requires":["Driver instantiation with configuration options","Environment variables (optional, for credential management)"],"input_types":["Configuration dict or keyword arguments","Environment variables (NEO4J_PASSWORD, etc.)"],"output_types":["Configured driver instance","Configuration metadata"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-neo4j__cap_2","uri":"capability://automation.workflow.automatic.routing.and.load.balancing.for.neo4j.clusters","name":"automatic routing and load balancing for neo4j clusters","description":"RoutingDriver and RoutingAsyncDriver implement Neo4j's routing protocol to automatically discover cluster topology and distribute queries across read replicas and write leaders. The driver maintains a routing table fetched from seed servers, caches it with TTL-based expiration, and routes READ transactions to any server, WRITE transactions to leaders, and SCHEMA transactions to leaders. Automatic failover occurs when a server becomes unavailable; the routing table is refreshed and the transaction is retried on a healthy server.","intents":["I want my application to automatically use read replicas for read queries in a Neo4j cluster","I need automatic failover when a Neo4j server goes down without manual intervention","I want to scale read throughput by distributing queries across multiple cluster members"],"best_for":["Production Neo4j clusters with 3+ servers","Applications requiring high availability and automatic failover","Teams wanting transparent load balancing without application-level routing logic"],"limitations":["Routing table is cached with TTL; stale topology can cause transient failures if cluster changes rapidly","Automatic failover adds 100-500ms latency on server failure detection and retry","Routing only works with neo4j:// and neo4j+s:// URIs; direct bolt:// connections bypass routing"],"requires":["Neo4j 4.0+ cluster with routing protocol support","URI scheme neo4j:// or neo4j+s:// (not bolt://)","Network connectivity to at least one seed server in the cluster"],"input_types":["Cluster seed URI (neo4j://server1,server2,server3:7687)","Access mode (READ, WRITE, SCHEMA)","Bookmarks for causal consistency"],"output_types":["Routed connection to appropriate server","Query results with server metadata","Routing table updates"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-neo4j__cap_3","uri":"capability://automation.workflow.transaction.management.with.explicit.and.implicit.transaction.modes","name":"transaction management with explicit and implicit transaction modes","description":"Provides explicit transaction control via session.begin_transaction() for fine-grained transaction lifecycle management, and implicit auto-commit transactions via session.run() for single-query execution. Transactions support three access modes (READ, WRITE, SCHEMA) and optional metadata. The driver implements ACID semantics with automatic rollback on exception, bookmark-based causal consistency across transactions, and configurable retry logic for transient failures (up to 30 seconds by default).","intents":["I need to execute multiple queries in a single transaction with rollback on error","I want automatic retry for transient network failures without manual exception handling","I need causal consistency across multiple transactions using bookmarks"],"best_for":["Applications requiring multi-statement transactions with ACID guarantees","High-concurrency systems where transient failures are common","Distributed systems needing causal consistency across reads and writes"],"limitations":["Automatic retry adds latency (up to 30 seconds default); not suitable for real-time applications requiring <100ms response times","Bookmarks for causal consistency require explicit passing between transactions; no automatic propagation","Transaction timeout is server-side; client-side timeout requires manual implementation"],"requires":["Active session from driver.session()","Neo4j 4.0+ for bookmark support","Explicit transaction mode requires calling begin_transaction()"],"input_types":["Cypher query strings","Query parameters (dict)","Access mode (READ, WRITE, SCHEMA)","Transaction metadata (dict)","Bookmarks from previous transactions"],"output_types":["Transaction object with commit/rollback methods","Query results (records)","Bookmarks for causal consistency","Transaction metadata (execution time, server info)"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-neo4j__cap_4","uri":"capability://data.processing.analysis.result.streaming.and.lazy.evaluation.with.result.objects","name":"result streaming and lazy evaluation with result objects","description":"Executes queries and returns Result objects that implement lazy evaluation—records are fetched from the server on-demand as the application iterates, not all at once. Result objects expose record iteration, summary metadata (execution time, query plan, statistics), and result consumption patterns (fetch_all, single, next). The driver buffers records in a client-side queue to balance memory usage and network round-trips, with configurable fetch size. Summary objects provide query execution statistics, server info, and notification filtering.","intents":["I want to iterate over large result sets without loading all records into memory at once","I need query execution statistics, timing, and server information after running a query","I want to fetch only the first N records from a large result set efficiently"],"best_for":["Applications processing large result sets (millions of records)","Memory-constrained environments (embedded systems, serverless functions)","Monitoring and observability use cases requiring query statistics"],"limitations":["Lazy evaluation adds ~1-2ms per record fetch due to network round-trips; not suitable for queries requiring sub-millisecond latency","Result objects are tied to session lifecycle; consuming results after session close causes errors","Summary metadata is only available after all records are consumed or result is explicitly closed"],"requires":["Active session from driver.session()","Completed query execution (Result object returned)","Iteration or explicit result consumption method call"],"input_types":["Result object from session.run()","Fetch size configuration (optional)"],"output_types":["Record objects (dict-like, with node/relationship access)","Summary object (metadata, statistics, server info)","Notifications (warnings, deprecations)"],"categories":["data-processing-analysis","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-neo4j__cap_5","uri":"capability://data.processing.analysis.temporal.and.spatial.type.mapping.with.native.python.objects","name":"temporal and spatial type mapping with native python objects","description":"Automatically maps Neo4j temporal types (Date, Time, DateTime, Duration) and spatial types (Point, CartesianPoint) to native Python objects with full arithmetic and comparison support. The driver implements ISO 8601 parsing for temporal strings and WGS84/Cartesian coordinate handling for spatial types. Temporal objects support timezone-aware operations, and spatial objects support distance calculations and coordinate transformations. Type conversion is transparent during result deserialization.","intents":["I want to work with Neo4j temporal types (dates, times, durations) as native Python objects","I need to perform geographic queries with point coordinates and distance calculations","I want automatic type conversion without manual parsing of temporal/spatial strings"],"best_for":["Applications with temporal data (event timestamps, scheduling, time-series)","Geographic/location-based applications using spatial indexes","Data science workflows requiring native Python datetime/timedelta compatibility"],"limitations":["Timezone handling requires explicit timezone-aware datetime objects; naive datetimes may cause ambiguity","Spatial distance calculations use Haversine formula; accuracy is ±0.5% for large distances due to Earth curvature approximation","Temporal arithmetic (e.g., adding Duration to DateTime) is limited to Neo4j-supported operations; some Python datetime operations are not supported"],"requires":["Python 3.10+ with datetime module","Neo4j 4.0+ for full temporal/spatial type support","Query results containing temporal or spatial values"],"input_types":["Neo4j temporal types (Date, Time, DateTime, Duration)","Neo4j spatial types (Point with WGS84 or Cartesian coordinates)","ISO 8601 formatted strings (for temporal types)"],"output_types":["Python datetime.date, datetime.time, datetime.datetime objects","Python datetime.timedelta objects (for Duration)","Custom Point objects with coordinate access and distance methods"],"categories":["data-processing-analysis","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-neo4j__cap_6","uri":"capability://safety.moderation.authentication.with.pluggable.authentication.managers","name":"authentication with pluggable authentication managers","description":"Supports multiple authentication schemes (BASIC, BEARER, KERBEROS, CUSTOM) via pluggable AuthManager interface. Built-in managers include BasicAuthManager (username/password), BearerAuthManager (JWT tokens), and CustomAuthManager for custom schemes. Authentication credentials are passed at driver instantiation and cached for connection reuse. The driver supports authentication token refresh for long-lived connections, and secure credential storage via environment variables or external secret managers.","intents":["I want to authenticate with Neo4j using username/password, JWT tokens, or custom schemes","I need to rotate authentication credentials without restarting the application","I want to use environment variables or secret managers for secure credential storage"],"best_for":["Enterprise applications requiring multiple authentication schemes","Microservices using JWT or OAuth tokens for authentication","Applications with credential rotation requirements"],"limitations":["KERBEROS authentication requires system-level Kerberos configuration; not portable across all environments","Custom authentication managers require implementing AuthManager interface; no pre-built integrations for OAuth2 or SAML","Credential refresh requires explicit manager implementation; automatic refresh is not built-in"],"requires":["Neo4j 4.0+ with authentication support","Appropriate authentication scheme enabled on Neo4j server","AuthManager instance or credentials dict at driver instantiation"],"input_types":["Authentication scheme (BASIC, BEARER, KERBEROS, CUSTOM)","Credentials (username/password, token, custom data)","AuthManager instance"],"output_types":["Authenticated connection to Neo4j","Authentication token (for token-based schemes)","Authentication metadata"],"categories":["safety-moderation","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-neo4j__cap_7","uri":"capability://safety.moderation.secure.tls.ssl.connections.with.certificate.validation","name":"secure tls/ssl connections with certificate validation","description":"Supports encrypted connections via bolt+s:// (TLS with certificate validation) and bolt+ssc:// (TLS with self-signed certificate bypass). The driver validates server certificates against system CA bundles by default, with options to disable validation or provide custom CA certificates. Certificate validation errors raise SecurityException. Secure connections use TLS 1.2+ with configurable cipher suites. The driver supports both encrypted and unencrypted connections in the same application via URI scheme selection.","intents":["I want to encrypt database connections with TLS/SSL for production deployments","I need to validate server certificates against a custom CA for internal PKI","I want to bypass certificate validation for development/testing with self-signed certificates"],"best_for":["Production deployments requiring encrypted database connections","Enterprise environments with internal PKI and custom CAs","Compliance-sensitive applications (HIPAA, PCI-DSS, SOC2)"],"limitations":["bolt+ssc:// (self-signed bypass) is insecure and should never be used in production; vulnerable to MITM attacks","Certificate validation adds ~5-10ms latency per connection due to cryptographic operations","Custom CA certificates must be provided as PEM files; no support for Windows certificate store"],"requires":["Neo4j server with TLS/SSL enabled","URI scheme bolt+s:// or bolt+ssc://","System CA bundle or custom CA certificate file (for bolt+s://)"],"input_types":["URI scheme (bolt+s:// or bolt+ssc://)","Custom CA certificate path (optional)","Cipher suite configuration (optional)"],"output_types":["Encrypted TLS connection","Certificate validation status","Connection metadata (cipher suite, TLS version)"],"categories":["safety-moderation","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-neo4j__cap_8","uri":"capability://automation.workflow.causal.consistency.with.bookmark.based.transaction.ordering","name":"causal consistency with bookmark-based transaction ordering","description":"Implements causal consistency via bookmarks—opaque tokens returned after each transaction that encode server-side transaction ordering. Bookmarks are passed to subsequent transactions via session.run(..., bookmarks=[...]) to ensure read-after-write consistency without distributed locks. The driver supports bookmark composition (combining multiple bookmarks) and bookmark filtering. Causal consistency is transparent to the application; the driver handles bookmark propagation automatically within a session.","intents":["I want to ensure read-after-write consistency in distributed Neo4j clusters","I need to order transactions causally without using distributed locks","I want to pass transaction ordering information between different sessions or services"],"best_for":["Distributed systems requiring causal consistency across multiple services","Applications with read-after-write consistency requirements","Multi-region deployments with eventual consistency"],"limitations":["Bookmarks are opaque tokens; no visibility into transaction ordering semantics","Bookmark passing between services requires manual serialization/deserialization","Causal consistency adds latency (100-500ms) waiting for server-side transaction ordering on read operations"],"requires":["Neo4j 4.0+ with bookmark support","Explicit bookmark passing via session.run(..., bookmarks=[...])","Bookmarks from previous transactions"],"input_types":["Bookmarks (list of opaque strings from previous transactions)","Query parameters"],"output_types":["Query results","Bookmarks for subsequent transactions","Transaction metadata"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-neo4j__cap_9","uri":"capability://automation.workflow.connection.pooling.with.configurable.pool.size.and.connection.lifecycle.management","name":"connection pooling with configurable pool size and connection lifecycle management","description":"Manages a pool of persistent TCP connections to Neo4j servers with configurable min/max pool size (default 1-100). The driver implements connection reuse for query execution, automatic connection eviction on idle timeout (default 30 minutes), and connection health checks via heartbeat pings. Pool exhaustion triggers backpressure (waiting for available connection) rather than connection creation. The driver supports per-session connection acquisition and release, with transparent connection recycling on server restart.","intents":["I want to reuse database connections across multiple queries to reduce connection overhead","I need to configure connection pool size for my application's concurrency requirements","I want automatic connection cleanup and health checks without manual management"],"best_for":["High-concurrency applications (100+ concurrent queries)","Long-running services requiring connection reuse","Applications with variable query load"],"limitations":["Pool exhaustion causes backpressure (blocking) rather than queuing; applications must handle connection wait times","Connection idle timeout (default 30 minutes) may cause stale connections in low-traffic applications","Pool size tuning requires profiling; incorrect sizing can cause connection exhaustion or memory waste"],"requires":["Driver instantiation with pool_size configuration (optional)","Active sessions for connection acquisition","Network connectivity to Neo4j server"],"input_types":["Pool size configuration (min_pool_size, max_pool_size)","Connection timeout (seconds)","Idle timeout (seconds)"],"output_types":["Pooled connections (transparent to application)","Pool statistics (active connections, idle connections, waiting requests)"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":29,"verified":false,"data_access_risk":"high","permissions":["Python 3.10 through 3.14","Neo4j server 4.4+ with Bolt protocol support","Network connectivity to Neo4j server on Bolt port (default 7687)","Python 3.10+ for async driver, Python 3.10+ for sync driver","asyncio event loop running (for async driver only)","URI with scheme: bolt://, bolt+s://, neo4j://, or neo4j+s://","Neo4j 4.0+ with notification support","Query execution returning Result object","Access to Result.summary().notifications","Python 3.10+"],"failure_modes":["Bolt 4.0-4.1 support has been dropped; requires Bolt 4.4 or higher","Optional Rust extension (neo4j-rust-ext) must be manually installed for acceleration; not included by default","PackStream serialization adds ~5-15ms per round-trip even with Rust acceleration","Async driver requires Python 3.10+ with full asyncio event loop support","Code must be fully async or fully sync; mixing sync and async drivers in same thread causes deadlocks","Async driver adds ~2-5ms overhead per context switch compared to pure sync","Notifications are server-side only; client-side query analysis is not performed","Notification filtering requires explicit NotificationFilter configuration; no default filtering","Some notifications may be noisy in high-volume query environments; filtering is recommended","Async driver requires Python 3.10+ with full asyncio support","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.05,"quality":0.35,"ecosystem":0.5900000000000001,"match_graph":0.25,"freshness":0.52,"weights":{"adoption":0.3,"quality":0.2,"ecosystem":0.15,"match_graph":0.23,"freshness":0.12}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-05-24T12:16:25.060Z","last_scraped_at":"2026-05-03T15:20:25.058Z","last_commit":null},"community":{"stars":null,"forks":null,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=pypi-neo4j","compare_url":"https://unfragile.ai/compare?artifact=pypi-neo4j"}},"signature":"0dIRZy4xUKkdXAqS42SKUjaUbD8/XPncqHApfJ5PCLiJD5a3zQbG/bVxXYi/olh/EIekF4dMD/4JJli73B5aDg==","signedAt":"2026-07-08T13:33:20.646Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/pypi-neo4j","artifact":"https://unfragile.ai/pypi-neo4j","verify":"https://unfragile.ai/api/v1/verify?slug=pypi-neo4j","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}