from langchain.chainsimport LLMChain, MapRerankDocumentsChain
from langchain.output_parsers.regeximport RegexParser
from langchain_core.promptsimport PromptTemplate
from langchain_openaiimport OpenAI

document_variable_name="context"
llm= OpenAI()
# The prompt here should take as an input variable the
# `document_variable_name`
# The actual prompt will need to be a lot more complex, this is just
# an example.
prompt_template=(
"What color are Bob's eyes? "
"Output both your answer and a score (1-10) of how confident "
"you are in the format: <Answer>\nScore: <Score>.\n\n"
"Provide no other commentary.\n\n"
"Context: {context}"
)
output_parser= RegexParser(
    regex=r"(.*?)\nScore: (.*)",
    output_keys=["answer","score"],
)
prompt= PromptTemplate(
    template=prompt_template,
    input_variables=["context"],
    output_parser=output_parser,
)
llm_chain= LLMChain(llm=llm, prompt=prompt)
chain= MapRerankDocumentsChain(
    llm_chain=llm_chain,
    document_variable_name=document_variable_name,
    rank_key="score",
    answer_key="answer",
)

response= chain.invoke(documents)
response["output_text"]

/langchain/libs/langchain/langchain/chains/llm.py:369: UserWarning: The apply_and_parse method is deprecated, instead pass an output parser directly to LLMChain.
  warnings.warn(

'Brown'

pip install-qU langgraph

import operator
from typingimport Annotated, List, TypedDict

from langchain_core.promptsimport ChatPromptTemplate
from langchain_openaiimport ChatOpenAI
from langgraph.constantsimport Send
from langgraph.graphimport END, START, StateGraph


classAnswerWithScore(TypedDict):
    answer:str
    score: Annotated[int,...,"Score from 1-10."]


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

prompt_template="What color are Bob's eyes?\n\nContext: {context}"
prompt= ChatPromptTemplate.from_template(prompt_template)

# The below chain formats context from a document into a prompt, then
# generates a response structured according to the AnswerWithScore schema.
map_chain= prompt| llm.with_structured_output(AnswerWithScore)

# Below we define the components that will make up the graph


# This will be the overall state of the graph.
# It will contain the input document contents, corresponding
# answers with scores, and a final answer.
classState(TypedDict):
    contents: List[str]
    answers_with_scores: Annotated[list, operator.add]
    answer:str


# This will be the state of the node that we will "map" all
# documents to in order to generate answers with scores
classMapState(TypedDict):
    content:str


# Here we define the logic to map out over the documents
# We will use this an edge in the graph
defmap_analyses(state: State):
# We will return a list of `Send` objects
# Each `Send` object consists of the name of a node in the graph
# as well as the state to send to that node
return[
        Send("generate_analysis",{"content": content})for contentin state["contents"]
]


# Here we generate an answer with score, given a document
asyncdefgenerate_analysis(state: MapState):
    response=await map_chain.ainvoke(state["content"])
return{"answers_with_scores":[response]}


# Here we will select the top answer
defpick_top_ranked(state: State):
    ranked_answers=sorted(
        state["answers_with_scores"], key=lambda x:-int(x["score"])
)
return{"answer": ranked_answers[0]}


# Construct the graph: here we put everything together to construct our graph
graph= StateGraph(State)
graph.add_node("generate_analysis", generate_analysis)
graph.add_node("pick_top_ranked", pick_top_ranked)
graph.add_conditional_edges(START, map_analyses,["generate_analysis"])
graph.add_edge("generate_analysis","pick_top_ranked")
graph.add_edge("pick_top_ranked", END)
app= graph.compile()

from IPython.displayimport Image

Image(app.get_graph().draw_mermaid_png())

result=await app.ainvoke({"contents":[doc.page_contentfor docin documents]})
result["answer"]

{'answer': 'Bob has brown eyes.', 'score': 10}