Using Neptune with LangChain

[nithinnair23]

Checked other resources

• I added a very descriptive title to this question.
• I searched the LangChain documentation with the integrated search.
• I used the GitHub search to find a similar question and didn't find it.

Commit to Help

• I commit to help with one of those options 👆

Example Code

from langchain_community.graphs import NeptuneGraph

host = "<neptune-host>"

port = 8182

use_https = True


graph = NeptuneGraph(host=host, port=port, use_https=use_https)

Description

Hello, I am trying to use the NeptuneGraph integration provided by Langchain on Link to Docs

I try passing the endpoint as host, but everytime the response is a timeout error. There isn't enough explanation on langchain's docs regarding what the issue might be also what am i actually supposed to pass as host in above code ???

System Info

Python 3.12
Langchain 0.2
Windows 10

[dosubot[bot]]

To avoid the timeout error when using the NeptuneGraph integration with LangChain, you should pass the Neptune cluster's endpoint as the host. This is typically in the format of a URL provided by AWS Neptune.

Here's an example of how you can set it up:

import boto3
from langchain.chains.graph_qa.neptune_sparql import NeptuneSparqlQAChain
from langchain_community.chat_models import BedrockChat
from langchain_community.graphs import NeptuneRdfGraph

host = "<your-neptune-cluster-endpoint>"
port = 8182  # change if different
region = "us-east-1"  # change if different
graph = NeptuneRdfGraph(host=host, port=port, use_iam_auth=True, region_name=region)

MODEL_ID = "anthropic.claude-v2"
bedrock_client = boto3.client("bedrock-runtime")
llm = BedrockChat(model_id=MODEL_ID, client=bedrock_client)

chain = NeptuneSparqlQAChain.from_llm(
    llm=llm,
    graph=graph,
    examples=EXAMPLES,
    verbose=True,
    top_K=10,
    return_intermediate_steps=True,
    return_direct=False,
)

Replace "<your-neptune-cluster-endpoint>" with the actual endpoint of your Neptune cluster. Ensure that the use_https parameter is set to True if you are using a secure connection, and that the sign parameter is set to True to sign the request payload. The NeptuneRdfGraph class in LangChain provides detailed options for configuring the connection, including use_iam_auth, use_https, and sign ^[1][2][3][4].

To continue talking to Dosu, mention @dosu.

[nithinnair23]

Hi, thanks for your prompt response. despite passing credentials_profile_name, region_name and use_iam_auth and all their combinations I am running into a timedout error.

What could be the source of this issue?

[dosubot[bot]]

The timeout error you are encountering could be due to the sign parameter. If the sign parameter is set to True, the request payload will be signed, which might cause a timeout if there are issues with the signing process or the credentials.

Try setting sign to False to see if it resolves the issue:

from langchain_community.graphs import NeptuneRdfGraph

host = "<your-neptune-cluster-endpoint>"
port = 8182  # change if different
region = "us-east-1"  # change if different

graph = NeptuneRdfGraph(
    host=host,
    port=port,
    use_https=True,
    use_iam_auth=True,
    region_name=region,
    sign=False  # Set sign to False
)

This will configure the client to use unsigned requests, which might help in diagnosing whether the signing process is causing the timeout. Additionally, ensure that you are using the correct service name, which defaults to neptunedata, and that your use_https parameter is set correctly based on your connection requirements ^[1][2].

To continue talking to Dosu, mention @dosu.

[nithinnair23]

I was not able to get any response, still it is giving timeout error.

On another note, I was able to establish connection on AWS sagemaker notebook. But I saw that the LLM I am using (Anthropic) for NeptuneOpenCypherQAChain is not generating proper opencypher queries, it is mistaking title for name and vice versa. Due to which ultimately the response from Neptune is empty list and hence the llm says I don't know, there is no data in source, how can I fix this...

[dosubot[bot]]

To resolve the timeout error and ensure that the LLM generates correct OpenCypher queries, follow these steps:

Resolving Timeout Error

1. Check Network Configuration: Ensure your Neptune cluster is accessible from your environment. Verify security group settings, VPC configurations, and any network ACLs.
2. Increase Timeout Settings: Increase the timeout settings for the boto3 client by configuring the Config object from botocore and passing it to the boto3 session.

Here's an example of how to modify the NeptuneGraph class to include a custom timeout setting:

from botocore.config import Config

class NeptuneGraph(BaseNeptuneGraph):
    def __init__(
        self,
        host: str,
        port: int = 8182,
        use_https: bool = True,
        client: Any = None,
        credentials_profile_name: Optional[str] = None,
        region_name: Optional[str] = None,
        sign: bool = True,
        timeout: int = 60  # Add a timeout parameter
    ) -> None:
        """Create a new Neptune graph wrapper instance."""

        try:
            if client is not None:
                self.client = client
            else:
                import boto3
                if credentials_profile_name is not None:
                    session = boto3.Session(profile_name=credentials_profile_name)
                else:
                    session = boto3.Session()

                client_params = {}
                if region_name:
                    client_params["region_name"] = region_name

                protocol = "https" if use_https else "http"

                client_params["endpoint_url"] = f"{protocol}://{host}:{port}"

                config = Config(connect_timeout=timeout, read_timeout=timeout)  # Set timeouts

                if sign:
                    self.client = session.client("neptunedata", **client_params, config=config)
                else:
                    from botocore import UNSIGNED
                    from botocore.config import Config

                    self.client = session.client(
                        "neptunedata",
                        **client_params,
                        config=Config(signature_version=UNSIGNED, connect_timeout=timeout, read_timeout=timeout),
                    )

        except ImportError:
            raise ImportError(
                "Could not import boto3 python package. "
                "Please install it with `pip install boto3`."
            )
        except Exception as e:
            if type(e).__name__ == "UnknownServiceError":
                raise ImportError(
                    "NeptuneGraph requires a boto3 version 1.28.38 or greater."
                    "Please install it with `pip install -U boto3`."
                ) from e
            else:
                raise ValueError(
                    "Could not load credentials to authenticate with AWS client. "
                    "Please check that credentials in the specified "
                    "profile name are valid."
                ) from e

        try:
            self._refresh_schema()
        except Exception as e:
            raise NeptuneQueryException(
                {
                    "message": "Could not get schema for Neptune database",
                    "detail": str(e),
                }
            )

Ensuring Correct OpenCypher Queries

1. Validate Queries: Implement a validation step to check the syntax and structure of the generated OpenCypher queries before executing them.
2. Schema Awareness: Make sure the LLM is aware of the schema of your Neptune database. Refresh the schema and provide it as context to the LLM.
3. Error Handling: Implement robust error handling to catch and log any issues with the generated queries, providing feedback to improve future query generation.

Here is an example of how to set up the NeptuneOpenCypherQAChain to ensure correct query generation:

from langchain_community.graphs import NeptuneGraph
from langchain.chains import NeptuneOpenCypherQAChain
from langchain_openai import ChatOpenAI

host = "<neptune-host>"
port = 8182
use_https = True

graph = NeptuneGraph(host=host, port=port, use_https=use_https)

llm = ChatOpenAI(temperature=0, model="gpt-4")

chain = NeptuneOpenCypherQAChain.from_llm(llm=llm, graph=graph)

result = chain.invoke("how many outgoing routes does the Austin airport have?")
print(result)

The NeptuneOpenCypherQAChain class includes methods to generate OpenCypher statements and query the Neptune database. It uses a prompt selector to choose the appropriate prompt for generating OpenCypher queries and includes methods to extract and trim the generated queries ^[1][2][3][4].

To continue talking to Dosu, mention @dosu.