GraphCypherQAChain doesn't support returning source documents with `return_source_documents` param like the `BaseQAWithSourcesChain` chains
Labels: name: auto:bug, name: area: models, name: integration: chroma

### System Info

python==3.10
langchain==0.0.326
langdetect==1.0.9
langsmith==0.0.54

### Who can help?

_No response_

### Information

- [ ] The official example notebooks/scripts
- [X] My own modified scripts

### Related Components

- [X] LLMs/Chat Models
- [ ] Embedding Models
- [ ] Prompts / Prompt Templates / Prompt Selectors
- [ ] Output Parsers
- [ ] Document Loaders
- [ ] Vector Stores / Retrievers
- [ ] Memory
- [ ] Agents / Agent Executors
- [ ] Tools / Toolkits
- [X] Chains
- [ ] Callbacks/Tracing
- [ ] Async

### Reproduction

1. define `GraphCypherQAChain` chain to query over Neo4j graph db and construct cypher query then return answer to user's question while setting `return_source_documents` to `True`:
`   graph = Neo4jGraph(
        url=NEO4J_URL, username=NEO4J_USERNAME, password=NEO4J_PASSWORD
        )


    EXAMPLES_PROMPT_TEMPLATE = """   
                    Input: {db_question},
                    Output: {db_query}
                """
                                

    example_prompt = PromptTemplate(input_variables=["db_question", "db_query"], template=EXAMPLES_PROMPT_TEMPLATE)

    example_selector = MaxMarginalRelevanceExampleSelector.from_examples(
        # This is the list of examples available to select from.
        query_examples,
        # This is the embedding class used to produce embeddings which are used to measure semantic similarity.
        OpenAIEmbeddings(),
        # This is the VectorStore class that is used to store the embeddings and do a similarity search over.
        Chroma,
        # This is the number of examples to produce.
        k=2
    )

    prompt_cypher = FewShotPromptTemplate(
        example_selector=example_selector,
        example_prompt=example_prompt,
        suffix="The question is:\n{question}",
        prefix="""Task: Generate a Cypher query to query a graph database based on the user's question.
    Instructions:
    Use the provided schema for node types, relationship types, and properties in the graph database. Only incorporate these defined elements.
    Avoid utilizing any other node types, relationship types, or properties not present in the provided schema. Here's the schema definition:

    {schema}

    if the question matches one of the sample questions in the knowledge base then just return the query used to answer it.
    if the user asks to retrieve a piece of information about a document or section given their name, then use a `WHERE` statement 
    and a cypher regular expression matching without case sensitivity like in the queries in your knowledge base when filtering by the name. 

    Use the statement `(t:transaction)-[:CONTAINS*]->(s)` in the cypher query
    with the `*` sign next to the relationship label `CONTAINS` and where s is the section node you are looking for.


    Ensure the generated query captures relevant information from the graph database without reducing the retrieved data due to variations in user wording.
    Note: do not include any explanations or apologies in your responses. 
    Do not respond to inquiries seeking information other than the construction of a Cypher statement.
    Do not include any text except the generated Cypher statement.
    """,
        input_variables=["schema", "question"]
    )


    QA_GENERATION_TEMPLATE = """
            Task: answer the question you are given based on the context provided.
            Instructions:
            You are an assistant that helps to form nice and human understandable answers. 
            Use the context information provided to generate a well organized and comprehensve answer to the user's question. 
            When the provided information contains multiple elements, structure your answer as a bulleted or numbered list to enhance clarity and readability.
            You must use the information to construct your answer. 
            The provided information is authoritative; do not doubt it or try to use your internal knowledge to correct it. 
            Make the answer sound like a response to the question without mentioning that you based the result on the given information. 

            Here's the information:
            {context}
            

            Question: {question}
            Answer:
                """
                

    prompt_qa = PromptTemplate(input_variables=["context", "question"], template=QA_GENERATION_TEMPLATE)


    chain = GraphCypherQAChain.from_llm(
        cypher_llm=ChatOpenAI(temperature=0, model="gpt-4"),
        qa_llm=ChatOpenAI(temperature=0, model="gpt-4"),
        graph=graph,
        verbose=True,
        return_intermediate_steps=True,
        return_source_documents=True,
        validate_cypher=True,
        cypher_prompt=prompt_cypher,
        qa_prompt=prompt_qa
    )`

2. run chain and retrieve source docs used to answer question:
` res = chain.run({)) # chatbot response

  answer = res['result']
  
  print("source_documents" in res)
  print(res.get("source_documents"))`



### Expected behavior

output is expected to be the source files that were queried or a similar output indicating the high level graph elements that were used to construct the context passed in the prompt.