Spaces:
Running
Running
| from neo4j import GraphDatabase, Driver, exceptions | |
| from .config import settings | |
| import logging | |
| from typing import List, Dict, Any, Optional | |
| logger = logging.getLogger(__name__) | |
| class Neo4jClient: | |
| _driver: Optional[Driver] = None | |
| def _get_driver(self) -> Driver: | |
| """Initializes and returns the Neo4j driver instance.""" | |
| if self._driver is None or self._driver.close(): | |
| logger.info(f"Initializing Neo4j Driver for URI: {settings.neo4j_uri}") | |
| try: | |
| self._driver = GraphDatabase.driver( | |
| settings.neo4j_uri, | |
| auth=(settings.neo4j_username, settings.neo4j_password.get_secret_value()) | |
| ) | |
| # Verify connectivity during initialization | |
| self._driver.verify_connectivity() | |
| logger.info("Neo4j Driver initialized and connection verified.") | |
| except exceptions.AuthError as e: | |
| logger.error(f"Neo4j Authentication Error: {e}", exc_info=True) | |
| raise ConnectionError("Neo4j Authentication Failed. Check credentials.") from e | |
| except exceptions.ServiceUnavailable as e: | |
| logger.error(f"Neo4j Service Unavailable: {e}", exc_info=True) | |
| raise ConnectionError(f"Could not connect to Neo4j at {settings.neo4j_uri}. Ensure DB is running and reachable.") from e | |
| except Exception as e: | |
| logger.error(f"Unexpected error initializing Neo4j Driver: {e}", exc_info=True) | |
| raise ConnectionError("An unexpected error occurred connecting to Neo4j.") from e | |
| return self._driver | |
| def close(self): | |
| """Closes the Neo4j driver connection.""" | |
| if self._driver and not self._driver.close(): | |
| logger.info("Closing Neo4j Driver.") | |
| self._driver.close() | |
| self._driver = None | |
| def query(self, cypher_query: str, params: Optional[Dict[str, Any]] = None) -> List[Dict[str, Any]]: | |
| """Executes a Cypher query and returns the results.""" | |
| driver = self._get_driver() | |
| logger.debug(f"Executing Cypher: {cypher_query} with params: {params}") | |
| try: | |
| # Use session/transaction for robust execution | |
| with driver.session() as session: | |
| result = session.run(cypher_query, params or {}) | |
| # Convert Neo4j Records to dictionaries | |
| data = [record.data() for record in result] | |
| logger.debug(f"Query returned {len(data)} records.") | |
| return data | |
| except (exceptions.ServiceUnavailable, exceptions.SessionExpired) as e: | |
| logger.error(f"Neo4j connection error during query: {e}", exc_info=True) | |
| # Attempt to close the potentially broken driver so it reconnects next time | |
| self.close() | |
| raise ConnectionError("Neo4j connection error during query execution.") from e | |
| except exceptions.CypherSyntaxError as e: | |
| logger.error(f"Neo4j Cypher Syntax Error: {e}\nQuery: {cypher_query}", exc_info=True) | |
| raise ValueError("Invalid Cypher query syntax.") from e | |
| except Exception as e: | |
| logger.error(f"Unexpected error during Neo4j query: {e}", exc_info=True) | |
| raise RuntimeError("An unexpected error occurred during the Neo4j query.") from e | |
| def get_schema(self, force_refresh: bool = False) -> Dict[str, Any]: | |
| """ Fetches the graph schema. Placeholder - Langchain community graph has better schema fetching.""" | |
| # For simplicity, returning empty. Implement actual schema fetching if needed. | |
| # Consider using langchain_community.graphs.Neo4jGraph for schema handling if complex interactions are needed. | |
| logger.warning("Neo4jClient.get_schema() is a placeholder. Implement if schema needed.") | |
| return {} # Placeholder | |
| def get_concepts(self) -> List[str]: | |
| """Fetches all Concept names from the graph.""" | |
| cypher = "MATCH (c:Concept) RETURN c.name AS name ORDER BY name" | |
| results = self.query(cypher) | |
| return [record['name'] for record in results if 'name' in record] | |
| def get_concept_description(self, concept_name: str) -> Optional[str]: | |
| """Fetches the description for a specific concept.""" | |
| cypher = "MATCH (c:Concept {name: $name}) RETURN c.description AS description LIMIT 1" | |
| params = {"name": concept_name} | |
| results = self.query(cypher, params) | |
| return results[0]['description'] if results and 'description' in results[0] else None | |
| # Create a single instance for the application to use | |
| neo4j_client = Neo4jClient() | |
| # Ensure the client is closed gracefully when the application exits | |
| import atexit | |
| atexit.register(neo4j_client.close) |