From fb0091fd5753dcbed650b3005678ffd864d7bfbf Mon Sep 17 00:00:00 2001 From: Mason Daugherty Date: Tue, 13 Jan 2026 01:26:48 -0500 Subject: [PATCH] docs: restore `examples/` (#6682) --- examples/README.md | 3 + examples/async.ipynb | 33 + examples/branching.ipynb | 33 + .../agent-simulation-evaluation.ipynb | 33 + ...angsmith-agent-simulation-evaluation.ipynb | 33 + .../simulation_utils.py | 203 ++++ .../information-gather-prompting.ipynb | 33 + .../langgraph_to_langgraph_cloud.ipynb | 33 + .../langgraph_code_assistant.ipynb | 33 + .../langgraph_code_assistant_mistral.ipynb | 298 ++++++ examples/configuration.ipynb | 33 + examples/create-react-agent-hitl.ipynb | 33 + examples/create-react-agent-memory.ipynb | 33 + .../create-react-agent-system-prompt.ipynb | 33 + examples/create-react-agent.ipynb | 33 + .../customer-support/customer-support.ipynb | 33 + examples/extraction/retries.ipynb | 33 + .../human_in_the_loop/wait-user-input.ipynb | 33 + examples/input_output_schema.ipynb | 33 + examples/lats/lats.ipynb | 33 + examples/llm-compiler/LLMCompiler.ipynb | 33 + examples/map-reduce.ipynb | 33 + .../add-summary-conversation-history.ipynb | 33 + examples/memory/delete-messages.ipynb | 33 + .../memory/manage-conversation-history.ipynb | 33 + .../hierarchical_agent_teams.ipynb | 33 + .../multi-agent-collaboration.ipynb | 33 + examples/node-retries.ipynb | 33 + examples/pass-config-to-tools.ipynb | 33 + examples/pass-run-time-values-to-tools.ipynb | 33 + examples/pass_private_state.ipynb | 33 + examples/persistence.ipynb | 33 + examples/persistence_mongodb.ipynb | 33 + examples/persistence_postgres.ipynb | 33 + examples/persistence_redis.ipynb | 33 + .../plan-and-execute/plan-and-execute.ipynb | 33 + examples/rag/langgraph_adaptive_rag.ipynb | 930 ++++++++++++++++++ .../rag/langgraph_adaptive_rag_cohere.ipynb | 597 +++++++++++ .../rag/langgraph_adaptive_rag_local.ipynb | 838 ++++++++++++++++ examples/rag/langgraph_agentic_rag.ipynb | 539 ++++++++++ examples/rag/langgraph_crag.ipynb | 701 +++++++++++++ examples/rag/langgraph_crag_local.ipynb | 853 ++++++++++++++++ examples/rag/langgraph_self_rag.ipynb | 792 +++++++++++++++ examples/rag/langgraph_self_rag_local.ipynb | 747 ++++++++++++++ .../langgraph_self_rag_pinecone_movies.ipynb | 474 +++++++++ examples/react-agent-from-scratch.ipynb | 33 + examples/react-agent-structured-output.ipynb | 33 + examples/recursion-limit.ipynb | 33 + examples/reflection/reflection.ipynb | 33 + examples/reflexion/reflexion.ipynb | 33 + examples/rewoo/rewoo.ipynb | 33 + examples/run-id-langsmith.ipynb | 33 + examples/self-discover/self-discover.ipynb | 33 + examples/state-model.ipynb | 33 + examples/storm/storm.ipynb | 33 + examples/stream-multiple.ipynb | 33 + examples/stream-updates.ipynb | 33 + examples/stream-values.ipynb | 33 + examples/streaming-content.ipynb | 33 + ...-from-within-tools-without-langchain.ipynb | 33 + .../streaming-events-from-within-tools.ipynb | 33 + examples/streaming-from-final-node.ipynb | 33 + examples/streaming-subgraphs.ipynb | 33 + .../streaming-tokens-without-langchain.ipynb | 33 + examples/streaming-tokens.ipynb | 33 + examples/subgraph-transform-state.ipynb | 33 + examples/subgraph.ipynb | 33 + examples/subgraphs-manage-state.ipynb | 33 + examples/tool-calling-errors.ipynb | 33 + examples/tool-calling.ipynb | 33 + examples/tutorials/sql-agent.ipynb | 33 + examples/tutorials/tnt-llm/tnt-llm.ipynb | 33 + examples/usaco/usaco.ipynb | 33 + examples/visualization.ipynb | 33 + examples/web-navigation/web_voyager.ipynb | 33 + 75 files changed, 9054 insertions(+) create mode 100644 examples/README.md create mode 100644 examples/async.ipynb create mode 100644 examples/branching.ipynb create mode 100644 examples/chatbot-simulation-evaluation/agent-simulation-evaluation.ipynb create mode 100644 examples/chatbot-simulation-evaluation/langsmith-agent-simulation-evaluation.ipynb create mode 100644 examples/chatbot-simulation-evaluation/simulation_utils.py create mode 100644 examples/chatbots/information-gather-prompting.ipynb create mode 100644 examples/cloud_examples/langgraph_to_langgraph_cloud.ipynb create mode 100644 examples/code_assistant/langgraph_code_assistant.ipynb create mode 100644 examples/code_assistant/langgraph_code_assistant_mistral.ipynb create mode 100644 examples/configuration.ipynb create mode 100644 examples/create-react-agent-hitl.ipynb create mode 100644 examples/create-react-agent-memory.ipynb create mode 100644 examples/create-react-agent-system-prompt.ipynb create mode 100644 examples/create-react-agent.ipynb create mode 100644 examples/customer-support/customer-support.ipynb create mode 100644 examples/extraction/retries.ipynb create mode 100644 examples/human_in_the_loop/wait-user-input.ipynb create mode 100644 examples/input_output_schema.ipynb create mode 100644 examples/lats/lats.ipynb create mode 100644 examples/llm-compiler/LLMCompiler.ipynb create mode 100644 examples/map-reduce.ipynb create mode 100644 examples/memory/add-summary-conversation-history.ipynb create mode 100644 examples/memory/delete-messages.ipynb create mode 100644 examples/memory/manage-conversation-history.ipynb create mode 100644 examples/multi_agent/hierarchical_agent_teams.ipynb create mode 100644 examples/multi_agent/multi-agent-collaboration.ipynb create mode 100644 examples/node-retries.ipynb create mode 100644 examples/pass-config-to-tools.ipynb create mode 100644 examples/pass-run-time-values-to-tools.ipynb create mode 100644 examples/pass_private_state.ipynb create mode 100644 examples/persistence.ipynb create mode 100644 examples/persistence_mongodb.ipynb create mode 100644 examples/persistence_postgres.ipynb create mode 100644 examples/persistence_redis.ipynb create mode 100644 examples/plan-and-execute/plan-and-execute.ipynb create mode 100644 examples/rag/langgraph_adaptive_rag.ipynb create mode 100644 examples/rag/langgraph_adaptive_rag_cohere.ipynb create mode 100644 examples/rag/langgraph_adaptive_rag_local.ipynb create mode 100644 examples/rag/langgraph_agentic_rag.ipynb create mode 100644 examples/rag/langgraph_crag.ipynb create mode 100644 examples/rag/langgraph_crag_local.ipynb create mode 100644 examples/rag/langgraph_self_rag.ipynb create mode 100644 examples/rag/langgraph_self_rag_local.ipynb create mode 100644 examples/rag/langgraph_self_rag_pinecone_movies.ipynb create mode 100644 examples/react-agent-from-scratch.ipynb create mode 100644 examples/react-agent-structured-output.ipynb create mode 100644 examples/recursion-limit.ipynb create mode 100644 examples/reflection/reflection.ipynb create mode 100644 examples/reflexion/reflexion.ipynb create mode 100644 examples/rewoo/rewoo.ipynb create mode 100644 examples/run-id-langsmith.ipynb create mode 100644 examples/self-discover/self-discover.ipynb create mode 100644 examples/state-model.ipynb create mode 100644 examples/storm/storm.ipynb create mode 100644 examples/stream-multiple.ipynb create mode 100644 examples/stream-updates.ipynb create mode 100644 examples/stream-values.ipynb create mode 100644 examples/streaming-content.ipynb create mode 100644 examples/streaming-events-from-within-tools-without-langchain.ipynb create mode 100644 examples/streaming-events-from-within-tools.ipynb create mode 100644 examples/streaming-from-final-node.ipynb create mode 100644 examples/streaming-subgraphs.ipynb create mode 100644 examples/streaming-tokens-without-langchain.ipynb create mode 100644 examples/streaming-tokens.ipynb create mode 100644 examples/subgraph-transform-state.ipynb create mode 100644 examples/subgraph.ipynb create mode 100644 examples/subgraphs-manage-state.ipynb create mode 100644 examples/tool-calling-errors.ipynb create mode 100644 examples/tool-calling.ipynb create mode 100644 examples/tutorials/sql-agent.ipynb create mode 100644 examples/tutorials/tnt-llm/tnt-llm.ipynb create mode 100644 examples/usaco/usaco.ipynb create mode 100644 examples/visualization.ipynb create mode 100644 examples/web-navigation/web_voyager.ipynb diff --git a/examples/README.md b/examples/README.md new file mode 100644 index 000000000..4ab3d1dbb --- /dev/null +++ b/examples/README.md @@ -0,0 +1,3 @@ +# LangGraph examples + +This directory should NOT be used for documentation. All new documentation must be added to `docs/docs/` directory. \ No newline at end of file diff --git a/examples/async.ipynb b/examples/async.ipynb new file mode 100644 index 000000000..9a641c887 --- /dev/null +++ b/examples/async.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "23544406", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/how-tos/async.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/branching.ipynb b/examples/branching.ipynb new file mode 100644 index 000000000..4b27bfd35 --- /dev/null +++ b/examples/branching.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "14f7ca50", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/how-tos/branching.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/chatbot-simulation-evaluation/agent-simulation-evaluation.ipynb b/examples/chatbot-simulation-evaluation/agent-simulation-evaluation.ipynb new file mode 100644 index 000000000..0b61a48ed --- /dev/null +++ b/examples/chatbot-simulation-evaluation/agent-simulation-evaluation.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "10251c1c", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/tutorials/chatbot-simulation-evaluation/agent-simulation-evaluation.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/chatbot-simulation-evaluation/langsmith-agent-simulation-evaluation.ipynb b/examples/chatbot-simulation-evaluation/langsmith-agent-simulation-evaluation.ipynb new file mode 100644 index 000000000..fa6531b45 --- /dev/null +++ b/examples/chatbot-simulation-evaluation/langsmith-agent-simulation-evaluation.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "a4351a24", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/tutorials/chatbot-simulation-evaluation/langsmith-agent-simulation-evaluation.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/chatbot-simulation-evaluation/simulation_utils.py b/examples/chatbot-simulation-evaluation/simulation_utils.py new file mode 100644 index 000000000..be3b32e8c --- /dev/null +++ b/examples/chatbot-simulation-evaluation/simulation_utils.py @@ -0,0 +1,203 @@ +import functools +from typing import Annotated, Any, Callable, Dict, List, Optional, Union + +from langchain_community.adapters.openai import convert_message_to_dict +from langchain_core.messages import AIMessage, AnyMessage, BaseMessage, HumanMessage +from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder +from langchain_core.runnables import Runnable, RunnableLambda +from langchain_core.runnables import chain as as_runnable +from langchain_openai import ChatOpenAI +from typing_extensions import TypedDict + +from langgraph.graph import END, StateGraph, START + + +def langchain_to_openai_messages(messages: List[BaseMessage]): + """ + Convert a list of langchain base messages to a list of openai messages. + + Parameters: + messages (List[BaseMessage]): A list of langchain base messages. + + Returns: + List[dict]: A list of openai messages. + """ + + return [ + convert_message_to_dict(m) if isinstance(m, BaseMessage) else m + for m in messages + ] + + +def create_simulated_user( + system_prompt: str, llm: Runnable | None = None +) -> Runnable[Dict, AIMessage]: + """ + Creates a simulated user for chatbot simulation. + + Args: + system_prompt (str): The system prompt to be used by the simulated user. + llm (Runnable | None, optional): The language model to be used for the simulation. + Defaults to gpt-3.5-turbo. + + Returns: + Runnable[Dict, AIMessage]: The simulated user for chatbot simulation. + """ + return ChatPromptTemplate.from_messages( + [ + ("system", system_prompt), + MessagesPlaceholder(variable_name="messages"), + ] + ) | (llm or ChatOpenAI(model="gpt-3.5-turbo")).with_config( + run_name="simulated_user" + ) + + +Messages = Union[list[AnyMessage], AnyMessage] + + +def add_messages(left: Messages, right: Messages) -> Messages: + if not isinstance(left, list): + left = [left] + if not isinstance(right, list): + right = [right] + return left + right + + +class SimulationState(TypedDict): + """ + Represents the state of a simulation. + + Attributes: + messages (List[AnyMessage]): A list of messages in the simulation. + inputs (Optional[dict[str, Any]]): Optional inputs for the simulation. + """ + + messages: Annotated[List[AnyMessage], add_messages] + inputs: Optional[dict[str, Any]] + + +def create_chat_simulator( + assistant: ( + Callable[[List[AnyMessage]], str | AIMessage] + | Runnable[List[AnyMessage], str | AIMessage] + ), + simulated_user: Runnable[Dict, AIMessage], + *, + input_key: str, + max_turns: int = 6, + should_continue: Optional[Callable[[SimulationState], str]] = None, +): + """Creates a chat simulator for evaluating a chatbot. + + Args: + assistant: The chatbot assistant function or runnable object. + simulated_user: The simulated user object. + input_key: The key for the input to the chat simulation. + max_turns: The maximum number of turns in the chat simulation. Default is 6. + should_continue: Optional function to determine if the simulation should continue. + If not provided, a default function will be used. + + Returns: + The compiled chat simulation graph. + + """ + graph_builder = StateGraph(SimulationState) + graph_builder.add_node( + "user", + _create_simulated_user_node(simulated_user), + ) + graph_builder.add_node( + "assistant", _fetch_messages | assistant | _coerce_to_message + ) + graph_builder.add_edge("assistant", "user") + graph_builder.add_conditional_edges( + "user", + should_continue or functools.partial(_should_continue, max_turns=max_turns), + ) + # If your dataset has a 'leading question/input', then we route first to the assistant, otherwise, we let the user take the lead. + graph_builder.add_edge(START, "assistant" if input_key is not None else "user") + + return ( + RunnableLambda(_prepare_example).bind(input_key=input_key) + | graph_builder.compile() + ) + + +## Private methods + + +def _prepare_example(inputs: dict[str, Any], input_key: Optional[str] = None): + if input_key is not None: + if input_key not in inputs: + raise ValueError( + f"Dataset's example input must contain the provided input key: '{input_key}'.\nFound: {list(inputs.keys())}" + ) + messages = [HumanMessage(content=inputs[input_key])] + return { + "inputs": {k: v for k, v in inputs.items() if k != input_key}, + "messages": messages, + } + return {"inputs": inputs, "messages": []} + + +def _invoke_simulated_user(state: SimulationState, simulated_user: Runnable): + """Invoke the simulated user node.""" + runnable = ( + simulated_user + if isinstance(simulated_user, Runnable) + else RunnableLambda(simulated_user) + ) + inputs = state.get("inputs", {}) + inputs["messages"] = state["messages"] + return runnable.invoke(inputs) + + +def _swap_roles(state: SimulationState): + new_messages = [] + for m in state["messages"]: + if isinstance(m, AIMessage): + new_messages.append(HumanMessage(content=m.content)) + else: + new_messages.append(AIMessage(content=m.content)) + return { + "inputs": state.get("inputs", {}), + "messages": new_messages, + } + + +@as_runnable +def _fetch_messages(state: SimulationState): + """Invoke the simulated user node.""" + return state["messages"] + + +def _convert_to_human_message(message: BaseMessage): + return {"messages": [HumanMessage(content=message.content)]} + + +def _create_simulated_user_node(simulated_user: Runnable): + """Simulated user accepts a {"messages": [...]} argument and returns a single message.""" + return ( + _swap_roles + | RunnableLambda(_invoke_simulated_user).bind(simulated_user=simulated_user) + | _convert_to_human_message + ) + + +def _coerce_to_message(assistant_output: str | BaseMessage): + if isinstance(assistant_output, str): + return {"messages": [AIMessage(content=assistant_output)]} + else: + return {"messages": [assistant_output]} + + +def _should_continue(state: SimulationState, max_turns: int = 6): + messages = state["messages"] + # TODO support other stop criteria + if len(messages) > max_turns: + return END + elif messages[-1].content.strip() == "FINISHED": + return END + else: + return "assistant" diff --git a/examples/chatbots/information-gather-prompting.ipynb b/examples/chatbots/information-gather-prompting.ipynb new file mode 100644 index 000000000..719ca2c89 --- /dev/null +++ b/examples/chatbots/information-gather-prompting.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "a9014f94", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/tutorials/chatbots/information-gather-prompting.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/cloud_examples/langgraph_to_langgraph_cloud.ipynb b/examples/cloud_examples/langgraph_to_langgraph_cloud.ipynb new file mode 100644 index 000000000..0cdef035c --- /dev/null +++ b/examples/cloud_examples/langgraph_to_langgraph_cloud.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "2b789e16", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/cloud/how-tos/langgraph_to_langgraph_cloud.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/code_assistant/langgraph_code_assistant.ipynb b/examples/code_assistant/langgraph_code_assistant.ipynb new file mode 100644 index 000000000..530c7de61 --- /dev/null +++ b/examples/code_assistant/langgraph_code_assistant.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "1f2f13ca", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/tutorials/code_assistant/langgraph_code_assistant.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/code_assistant/langgraph_code_assistant_mistral.ipynb b/examples/code_assistant/langgraph_code_assistant_mistral.ipynb new file mode 100644 index 000000000..1c666241f --- /dev/null +++ b/examples/code_assistant/langgraph_code_assistant_mistral.ipynb @@ -0,0 +1,298 @@ +{ + "cells": [ + { + "attachments": { + "15d3ac32-cdf3-4800-a30c-f26d828d69c8.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "6101c9d6-b7d1-46af-afab-47d05bfadeae", + "metadata": {}, + "source": [ + "# Code generation with self-correction\n", + "\n", + "AlphaCodium presented an approach for code generation that uses control flow.\n", + "\n", + "Main idea: [construct an answer to a coding question iteratively.](https://x.com/karpathy/status/1748043513156272416?s=20). \n", + "\n", + "[AlphaCodium](https://github.com/Codium-ai/AlphaCodium) iteravely tests and improves an answer on public and AI-generated tests for a particular question. \n", + "\n", + "We will implement some of these ideas from scratch using [LangGraph](https://langchain-ai.github.io/langgraph/):\n", + "\n", + "1. We show how to route user questions to different types of documentation\n", + "2. We we will show how to perform inline unit tests to confirm imports and code execution work\n", + "3. We will show how to use LangGraph to orchestrate this\n", + "\n", + "![Screenshot 2024-05-23 at 2.17.51 PM.png](attachment:15d3ac32-cdf3-4800-a30c-f26d828d69c8.png)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e501686f-323f-4b87-8f9c-8ba89133078b", + "metadata": {}, + "outputs": [], + "source": ["! pip install -U langchain_community langchain-mistralai langchain langgraph"] + }, + { + "cell_type": "markdown", + "id": "9ef4fb67-113a-4b88-9f93-7e3a95cee035", + "metadata": {}, + "source": [ + "### LLM\n", + "\n", + "We'll use the Mistral API and `Codestral` instruct model, which support tool use!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "982e4609-86e4-4934-828f-e03d89c20393", + "metadata": {}, + "outputs": [], + "source": ["import os\n\nos.environ[\"TOKENIZERS_PARALLELISM\"] = \"true\"\nmistral_api_key = os.getenv(\"MISTRAL_API_KEY\") # Ensure this is set"] + }, + { + "cell_type": "markdown", + "id": "6a20a3eb-6dc5-4a61-9705-9daf68172c0b", + "metadata": {}, + "source": [ + "### Tracing\n", + "\n", + "Optionally, we'll use LangSmith for tracing." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "37b172d2-3a9d-49a8-898c-22ed0cb45c88", + "metadata": {}, + "outputs": [], + "source": ["os.environ[\"LANGCHAIN_TRACING_V2\"] = \"true\"\nos.environ[\"LANGCHAIN_ENDPOINT\"] = \"https://api.smith.langchain.com\"\nos.environ[\"LANGCHAIN_API_KEY\"] = \"\"\nos.environ[\"LANGCHAIN_PROJECT\"] = \"Mistral-code-gen-testing\""] + }, + { + "cell_type": "markdown", + "id": "d3a3dca9-4485-4ae5-aa87-cd1f02bad8b9", + "metadata": {}, + "source": [ + "## Code Generation\n", + "\n", + "Test with structured output." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "a188c8ca-c053-4e6d-b7af-38a3b6b371c7", + "metadata": {}, + "outputs": [], + "source": ["# Select LLM\nfrom langchain_core.prompts import ChatPromptTemplate\nfrom langchain_core.pydantic_v1 import BaseModel, Field\nfrom langchain_mistralai import ChatMistralAI\n\nmistral_model = \"mistral-large-latest\"\nllm = ChatMistralAI(model=mistral_model, temperature=0)\n\n# Prompt\ncode_gen_prompt_claude = ChatPromptTemplate.from_messages(\n [\n (\n \"system\",\n \"\"\"You are a coding assistant. Ensure any code you provide can be executed with all required imports and variables \\n\n defined. Structure your answer: 1) a prefix describing the code solution, 2) the imports, 3) the functioning code block.\n \\n Here is the user question:\"\"\",\n ),\n (\"placeholder\", \"{messages}\"),\n ]\n)\n\n\n# Data model\nclass code(BaseModel):\n \"\"\"Code output\"\"\"\n\n prefix: str = Field(description=\"Description of the problem and approach\")\n imports: str = Field(description=\"Code block import statements\")\n code: str = Field(description=\"Code block not including import statements\")\n description = \"Schema for code solutions to questions about LCEL.\"\n\n\n# LLM\ncode_gen_chain = llm.with_structured_output(code, include_raw=False)"] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "9fc0290d-5a04-4514-8664-91f9dbf2da7b", + "metadata": {}, + "outputs": [], + "source": ["question = \"Write a function for fibonacci.\"\nmessages = [(\"user\", question)]"] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "973281bd-e74b-4386-98c6-210af5e31982", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "code(prefix='A function to calculate the nth Fibonacci number.', imports='', code='def fibonacci(n):\\n if n <= 0:\\n return \"Input should be positive integer\"\\n elif n == 1:\\n return 0\\n elif n == 2:\\n return 1\\n else:\\n a, b = 0, 1\\n for _ in range(2, n):\\n a, b = b, a + b\\n return b', description='Schema for code solutions to questions about LCEL.')" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": ["# Test\nresult = code_gen_chain.invoke(messages)\nresult"] + }, + { + "cell_type": "markdown", + "id": "4235eb2d-f5b3-4cd0-bbb1-a889eb5564d7", + "metadata": {}, + "source": [ + "## State" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "183d77b8-f180-4815-b39f-8ef507ec0534", + "metadata": {}, + "outputs": [], + "source": ["from typing import Annotated, TypedDict\n\nfrom langgraph.graph.message import AnyMessage, add_messages\n\n\nclass GraphState(TypedDict):\n \"\"\"\n Represents the state of our graph.\n\n Attributes:\n error : Binary flag for control flow to indicate whether test error was tripped\n messages : With user question, error messages, reasoning\n generation : Code solution\n iterations : Number of tries\n \"\"\"\n\n error: str\n messages: Annotated[list[AnyMessage], add_messages]\n generation: str\n iterations: int"] + }, + { + "cell_type": "markdown", + "id": "55043d78-c012-4280-bc8b-259f04a29cb4", + "metadata": {}, + "source": [ + "## Graph" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "14bc89d1-3ca6-4847-a048-1803e0e4600e", + "metadata": {}, + "outputs": [], + "source": ["import uuid\n\nfrom langchain_core.pydantic_v1 import BaseModel, Field\n\n### Parameters\nmax_iterations = 3\n\n\n### Nodes\ndef generate(state: GraphState):\n \"\"\"\n Generate a code solution\n\n Args:\n state (dict): The current graph state\n\n Returns:\n state (dict): New key added to state, generation\n \"\"\"\n\n print(\"---GENERATING CODE SOLUTION---\")\n\n # State\n messages = state[\"messages\"]\n iterations = state[\"iterations\"]\n\n # Solution\n code_solution = code_gen_chain.invoke(messages)\n messages += [\n (\n \"assistant\",\n f\"Here is my attempt to solve the problem: {code_solution.prefix} \\n Imports: {code_solution.imports} \\n Code: {code_solution.code}\",\n )\n ]\n\n # Increment\n iterations = iterations + 1\n return {\"generation\": code_solution, \"messages\": messages, \"iterations\": iterations}\n\n\ndef code_check(state: GraphState):\n \"\"\"\n Check code\n\n Args:\n state (dict): The current graph state\n\n Returns:\n state (dict): New key added to state, error\n \"\"\"\n\n print(\"---CHECKING CODE---\")\n\n # State\n messages = state[\"messages\"]\n code_solution = state[\"generation\"]\n iterations = state[\"iterations\"]\n\n # Get solution components\n imports = code_solution.imports\n code = code_solution.code\n\n # Check imports\n try:\n exec(imports)\n except Exception as e:\n print(\"---CODE IMPORT CHECK: FAILED---\")\n error_message = [\n (\n \"user\",\n f\"Your solution failed the import test. Here is the error: {e}. Reflect on this error and your prior attempt to solve the problem. (1) State what you think went wrong with the prior solution and (2) try to solve this problem again. Return the FULL SOLUTION. Use the code tool to structure the output with a prefix, imports, and code block:\",\n )\n ]\n messages += error_message\n return {\n \"generation\": code_solution,\n \"messages\": messages,\n \"iterations\": iterations,\n \"error\": \"yes\",\n }\n\n # Check execution\n try:\n combined_code = f\"{imports}\\n{code}\"\n print(f\"CODE TO TEST: {combined_code}\")\n # Use a shared scope for exec\n global_scope = {}\n exec(combined_code, global_scope)\n except Exception as e:\n print(\"---CODE BLOCK CHECK: FAILED---\")\n error_message = [\n (\n \"user\",\n f\"Your solution failed the code execution test: {e}) Reflect on this error and your prior attempt to solve the problem. (1) State what you think went wrong with the prior solution and (2) try to solve this problem again. Return the FULL SOLUTION. Use the code tool to structure the output with a prefix, imports, and code block:\",\n )\n ]\n messages += error_message\n return {\n \"generation\": code_solution,\n \"messages\": messages,\n \"iterations\": iterations,\n \"error\": \"yes\",\n }\n\n # No errors\n print(\"---NO CODE TEST FAILURES---\")\n return {\n \"generation\": code_solution,\n \"messages\": messages,\n \"iterations\": iterations,\n \"error\": \"no\",\n }\n\n\n### Conditional edges\n\n\ndef decide_to_finish(state: GraphState):\n \"\"\"\n Determines whether to finish.\n\n Args:\n state (dict): The current graph state\n\n Returns:\n str: Next node to call\n \"\"\"\n error = state[\"error\"]\n iterations = state[\"iterations\"]\n\n if error == \"no\" or iterations == max_iterations:\n print(\"---DECISION: FINISH---\")\n return \"end\"\n else:\n print(\"---DECISION: RE-TRY SOLUTION---\")\n return \"generate\"\n\n\n### Utilities\n\n\ndef _print_event(event: dict, _printed: set, max_length=1500):\n current_state = event.get(\"dialog_state\")\n if current_state:\n print(\"Currently in: \", current_state[-1])\n message = event.get(\"messages\")\n if message:\n if isinstance(message, list):\n message = message[-1]\n if message.id not in _printed:\n msg_repr = message.pretty_repr(html=True)\n if len(msg_repr) > max_length:\n msg_repr = msg_repr[:max_length] + \" ... (truncated)\"\n print(msg_repr)\n _printed.add(message.id)"] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "2dff2209-44c7-4e2c-b607-ba6675f9e45f", + "metadata": {}, + "outputs": [], + "source": ["from langgraph.checkpoint.memory import InMemorySaver\nfrom langgraph.graph import END, StateGraph, START\n\nbuilder = StateGraph(GraphState)\n\n# Define the nodes\nbuilder.add_node(\"generate\", generate) # generation solution\nbuilder.add_node(\"check_code\", code_check) # check code\n\n# Build graph\nbuilder.add_edge(START, \"generate\")\nbuilder.add_edge(\"generate\", \"check_code\")\nbuilder.add_conditional_edges(\n \"check_code\",\n decide_to_finish,\n {\n \"end\": END,\n \"generate\": \"generate\",\n },\n)\n\nmemory = InMemorySaver()\ngraph = builder.compile(checkpointer=memory)"] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "d4bb21cd-af20-4d4d-89ff-384db034b7c3", + "metadata": {}, + "outputs": [ + { + "data": { + "image/jpeg": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": ["from IPython.display import Image, display\n\ntry:\n display(Image(graph.get_graph(xray=True).draw_mermaid_png()))\nexcept Exception:\n # This requires some extra dependencies and is optional\n pass"] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "242aa2f0-2c31-462f-a958-ff9ae0cf7c62", + "metadata": {}, + "outputs": [], + "source": ["_printed = set()\nthread_id = str(uuid.uuid4())\nconfig = {\n \"configurable\": {\n # Checkpoints are accessed by thread_id\n \"thread_id\": thread_id,\n }\n}\n\nquestion = \"Write a Python program that prints 'Hello, World!' to the console.\"\nevents = graph.stream(\n {\"messages\": [(\"user\", question)], \"iterations\": 0}, config, stream_mode=\"values\"\n)\nfor event in events:\n _print_event(event, _printed)"] + }, + { + "cell_type": "markdown", + "id": "6924e707-5970-4254-a748-fa75628916f2", + "metadata": {}, + "source": [ + "`Trace:`\n", + "\n", + "https://smith.langchain.com/public/53bcdaab-e3c5-4423-9908-c44595325c38/r" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "390b2768-f395-4aea-8b0e-9d36212a31ac", + "metadata": {}, + "outputs": [], + "source": ["_printed = set()\nthread_id = str(uuid.uuid4())\nconfig = {\n \"configurable\": {\n # Checkpoints are accessed by thread_id\n \"thread_id\": thread_id,\n }\n}\n\nquestion = \"\"\"Create a Python program that checks if a given string is a palindrome. A palindrome is a word, phrase, number, or other sequence of characters that reads the same forward and backward (ignoring spaces, punctuation, and capitalization).\n\nRequirements:\nThe program should define a function is_palindrome(s) that takes a string s as input.\nThe function should return True if the string is a palindrome and False otherwise.\nIgnore spaces, punctuation, and case differences when checking for palindromes.\n\nGive an example of it working on an example input word.\"\"\"\n\nevents = graph.stream(\n {\"messages\": [(\"user\", question)], \"iterations\": 0}, config, stream_mode=\"values\"\n)\nfor event in events:\n _print_event(event, _printed)"] + }, + { + "cell_type": "markdown", + "id": "f96e0137-6df3-4a2a-8711-c9cb7dc66831", + "metadata": {}, + "source": [ + "Trace:\n", + "\n", + "https://smith.langchain.com/public/e749936d-7746-49de-b980-c41b17986e79/r" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0a3f946b-e2f2-44d9-905b-09f36980cf9f", + "metadata": {}, + "outputs": [], + "source": ["_printed = set()\nthread_id = str(uuid.uuid4())\nconfig = {\n \"configurable\": {\n # Checkpoints are accessed by thread_id\n \"thread_id\": thread_id,\n }\n}\n\nquestion = \"\"\"Write a program that prints the numbers from 1 to 100. \nBut for multiples of three, print \"Fizz\" instead of the number, and for the multiples of five, print \"Buzz\". \nFor numbers which are multiples of both three and five, print \"FizzBuzz\".\"\"\"\n\nevents = graph.stream(\n {\"messages\": [(\"user\", question)], \"iterations\": 0}, config, stream_mode=\"values\"\n)\nfor event in events:\n _print_event(event, _printed)"] + }, + { + "cell_type": "markdown", + "id": "8f3ef03b-0a07-49f5-9cbf-15e2503d020e", + "metadata": {}, + "source": [ + "Trace: \n", + "\n", + "https://smith.langchain.com/public/f5c19708-7592-4512-9f00-9696ab34a9eb/r" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2bb883df-540b-46ab-9415-fe27db68456f", + "metadata": {}, + "outputs": [], + "source": ["import uuid\n\n_printed = set()\nthread_id = str(uuid.uuid4())\nconfig = {\n \"configurable\": {\n # Checkpoints are accessed by thread_id\n \"thread_id\": thread_id,\n }\n}\n\nquestion = \"\"\"I want to vectorize a function\n\n frame = np.zeros((out_h, out_w, 3), dtype=np.uint8)\n for i, val1 in enumerate(rows):\n for j, val2 in enumerate(cols):\n for j, val3 in enumerate(ch):\n # Assuming you want to store the pair as tuples in the matrix\n frame[i, j, k] = image[val1, val2, val3]\n\n out.write(np.array(frame))\n\nwith a simple numpy function that does something like this what is it called. Show me a test case with this working.\"\"\"\n\nevents = graph.stream(\n {\"messages\": [(\"user\", question)], \"iterations\": 0}, config, stream_mode=\"values\"\n)\nfor event in events:\n _print_event(event, _printed)"] + }, + { + "cell_type": "markdown", + "id": "750a3292-1e0e-49cf-8b28-bef179afe6a2", + "metadata": {}, + "source": [ + "Trace w/ good example of self-correction:\n", + "\n", + "https://smith.langchain.com/public/b54778a0-d267-4f09-bc28-71761201c522/r" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ee05da1f-c272-405d-8a7b-552cfc3106e1", + "metadata": {}, + "outputs": [], + "source": ["_printed = set()\nthread_id = str(uuid.uuid4())\nconfig = {\n \"configurable\": {\n # Checkpoints are accessed by thread_id\n \"thread_id\": thread_id,\n }\n}\n\nquestion = \"\"\"Create a Python program that allows two players to play a game of Tic-Tac-Toe. The game should be played on a 3x3 grid. The program should:\n\n- Allow players to take turns to input their moves.\n- Check for invalid moves (e.g., placing a marker on an already occupied space).\n- Determine and announce the winner or if the game ends in a draw.\n\nRequirements:\n- Use a 2D list to represent the Tic-Tac-Toe board.\n- Use functions to modularize the code.\n- Validate player input.\n- Check for win conditions and draw conditions after each move.\"\"\"\n\nevents = graph.stream(\n {\"messages\": [(\"user\", question)], \"iterations\": 0}, config, stream_mode=\"values\"\n)\nfor event in events:\n _print_event(event, _printed)"] + }, + { + "cell_type": "markdown", + "id": "3d900cd6-2df9-467d-8e74-803527269008", + "metadata": {}, + "source": [ + "Trace w/ good example of failure to correct:\n", + "\n", + "https://smith.langchain.com/public/871ae736-2f77-44d4-b0da-a600d8f5377d/r" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "814fc2a4-8e5b-4faa-8f52-3977226bd09a", + "metadata": {}, + "outputs": [], + "source": [""] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/configuration.ipynb b/examples/configuration.ipynb new file mode 100644 index 000000000..93eaf3426 --- /dev/null +++ b/examples/configuration.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "e9a58c69", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/how-tos/configuration.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/create-react-agent-hitl.ipynb b/examples/create-react-agent-hitl.ipynb new file mode 100644 index 000000000..113b087ec --- /dev/null +++ b/examples/create-react-agent-hitl.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "a1e6efeb", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/how-tos/create-react-agent-hitl.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/create-react-agent-memory.ipynb b/examples/create-react-agent-memory.ipynb new file mode 100644 index 000000000..621374ca0 --- /dev/null +++ b/examples/create-react-agent-memory.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "1ef41a89", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/how-tos/create-react-agent-memory.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/create-react-agent-system-prompt.ipynb b/examples/create-react-agent-system-prompt.ipynb new file mode 100644 index 000000000..12bade9a4 --- /dev/null +++ b/examples/create-react-agent-system-prompt.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "9e2f7902", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/how-tos/create-react-agent-system-prompt.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/create-react-agent.ipynb b/examples/create-react-agent.ipynb new file mode 100644 index 000000000..336fbb581 --- /dev/null +++ b/examples/create-react-agent.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "eb07372e", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/how-tos/create-react-agent.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/customer-support/customer-support.ipynb b/examples/customer-support/customer-support.ipynb new file mode 100644 index 000000000..e9d4245cc --- /dev/null +++ b/examples/customer-support/customer-support.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "a8232bc9", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/tutorials/customer-support/customer-support.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/extraction/retries.ipynb b/examples/extraction/retries.ipynb new file mode 100644 index 000000000..3c6d92333 --- /dev/null +++ b/examples/extraction/retries.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "8dbdba5b", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/tutorials/extraction/retries.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/human_in_the_loop/wait-user-input.ipynb b/examples/human_in_the_loop/wait-user-input.ipynb new file mode 100644 index 000000000..5cc0539f6 --- /dev/null +++ b/examples/human_in_the_loop/wait-user-input.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "3ecab357", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/how-tos/human_in_the_loop/wait-user-input.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/input_output_schema.ipynb b/examples/input_output_schema.ipynb new file mode 100644 index 000000000..31977d817 --- /dev/null +++ b/examples/input_output_schema.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "fc0793cb", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/how-tos/input_output_schema.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/lats/lats.ipynb b/examples/lats/lats.ipynb new file mode 100644 index 000000000..0ba9dea76 --- /dev/null +++ b/examples/lats/lats.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "09038b53", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/tutorials/lats/lats.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/llm-compiler/LLMCompiler.ipynb b/examples/llm-compiler/LLMCompiler.ipynb new file mode 100644 index 000000000..100de4f66 --- /dev/null +++ b/examples/llm-compiler/LLMCompiler.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "85205e97", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/tutorials/llm-compiler/LLMCompiler.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/map-reduce.ipynb b/examples/map-reduce.ipynb new file mode 100644 index 000000000..60202320a --- /dev/null +++ b/examples/map-reduce.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "42abb708", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/how-tos/map-reduce.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/memory/add-summary-conversation-history.ipynb b/examples/memory/add-summary-conversation-history.ipynb new file mode 100644 index 000000000..4b95ed59e --- /dev/null +++ b/examples/memory/add-summary-conversation-history.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "298784f6", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/how-tos/memory/add-summary-conversation-history.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/memory/delete-messages.ipynb b/examples/memory/delete-messages.ipynb new file mode 100644 index 000000000..2c8dc13ff --- /dev/null +++ b/examples/memory/delete-messages.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "3f4370fd", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/how-tos/memory/delete-messages.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/memory/manage-conversation-history.ipynb b/examples/memory/manage-conversation-history.ipynb new file mode 100644 index 000000000..94535ad6b --- /dev/null +++ b/examples/memory/manage-conversation-history.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "6ec7cb13", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/how-tos/memory/manage-conversation-history.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/multi_agent/hierarchical_agent_teams.ipynb b/examples/multi_agent/hierarchical_agent_teams.ipynb new file mode 100644 index 000000000..3da01d221 --- /dev/null +++ b/examples/multi_agent/hierarchical_agent_teams.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "5cc8a2ad", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/tutorials/multi_agent/hierarchical_agent_teams.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/multi_agent/multi-agent-collaboration.ipynb b/examples/multi_agent/multi-agent-collaboration.ipynb new file mode 100644 index 000000000..d718f53d5 --- /dev/null +++ b/examples/multi_agent/multi-agent-collaboration.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d2b507b9", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/tutorials/multi_agent/multi-agent-collaboration.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/node-retries.ipynb b/examples/node-retries.ipynb new file mode 100644 index 000000000..65dedb2d4 --- /dev/null +++ b/examples/node-retries.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "017a01f4", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/how-tos/node-retries.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "env", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/pass-config-to-tools.ipynb b/examples/pass-config-to-tools.ipynb new file mode 100644 index 000000000..540f0815c --- /dev/null +++ b/examples/pass-config-to-tools.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "05f6ad0a", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/how-tos/pass-config-to-tools.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/examples/pass-run-time-values-to-tools.ipynb b/examples/pass-run-time-values-to-tools.ipynb new file mode 100644 index 000000000..728c5b9e6 --- /dev/null +++ b/examples/pass-run-time-values-to-tools.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "8f38bec5", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/how-tos/pass-run-time-values-to-tools.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/pass_private_state.ipynb b/examples/pass_private_state.ipynb new file mode 100644 index 000000000..9c6cf8929 --- /dev/null +++ b/examples/pass_private_state.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "4da17088", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/how-tos/pass_private_state.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/persistence.ipynb b/examples/persistence.ipynb new file mode 100644 index 000000000..a7a0e08b0 --- /dev/null +++ b/examples/persistence.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d16e8b9c", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/how-tos/memory/add-memory.md." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/persistence_mongodb.ipynb b/examples/persistence_mongodb.ipynb new file mode 100644 index 000000000..7bf76036e --- /dev/null +++ b/examples/persistence_mongodb.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "78217098", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/how-tos/persistence_mongodb.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/persistence_postgres.ipynb b/examples/persistence_postgres.ipynb new file mode 100644 index 000000000..7081e2ef3 --- /dev/null +++ b/examples/persistence_postgres.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "18526f23", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/how-tos/memory/add-memory.md" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/persistence_redis.ipynb b/examples/persistence_redis.ipynb new file mode 100644 index 000000000..20eaf89c2 --- /dev/null +++ b/examples/persistence_redis.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "eee6ecdd", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/how-tos/persistence_redis.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/plan-and-execute/plan-and-execute.ipynb b/examples/plan-and-execute/plan-and-execute.ipynb new file mode 100644 index 000000000..0f1811417 --- /dev/null +++ b/examples/plan-and-execute/plan-and-execute.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "9138f92e", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/tutorials/plan-and-execute/plan-and-execute.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/rag/langgraph_adaptive_rag.ipynb b/examples/rag/langgraph_adaptive_rag.ipynb new file mode 100644 index 000000000..8d9d26420 --- /dev/null +++ b/examples/rag/langgraph_adaptive_rag.ipynb @@ -0,0 +1,930 @@ +{ + "cells": [ + { + "attachments": { + "36fa621a-9d3d-4860-a17c-5d20e6987481.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "5afcaed0-3d55-4e1f-95d3-c32c751c29d8", + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, + "source": [ + "# Adaptive RAG\n", + "\n", + "Adaptive RAG is a strategy for RAG that unites (1) [query analysis](https://blog.langchain.dev/query-construction/) with (2) [active / self-corrective RAG](https://blog.langchain.dev/agentic-rag-with-langgraph/).\n", + "\n", + "In the [paper](https://arxiv.org/abs/2403.14403), they report query analysis to route across:\n", + "\n", + "* No Retrieval\n", + "* Single-shot RAG\n", + "* Iterative RAG\n", + "\n", + "Let's build on this using LangGraph. \n", + "\n", + "In our implementation, we will route between:\n", + "\n", + "* Web search: for questions related to recent events\n", + "* Self-corrective RAG: for questions related to our index\n", + "\n", + "![Screenshot 2024-03-26 at 1.36.03 PM.png](attachment:36fa621a-9d3d-4860-a17c-5d20e6987481.png)" + ] + }, + { + "cell_type": "markdown", + "id": "a85501ca-eb89-4795-aeab-cdab050ead6b", + "metadata": {}, + "source": [ + "## Setup\n", + "\n", + "First, let's install our required packages and set our API keys" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "53d1a740-9fea-4a6e-8f95-fb9dbf1c80a1", + "metadata": {}, + "outputs": [], + "source": [ + "%%capture --no-stderr\n", + "! pip install -U langchain_community tiktoken langchain-openai langchain-cohere langchainhub chromadb langchain langgraph tavily-python" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "222f204d-956f-4128-b597-2c698120edda", + "metadata": {}, + "outputs": [], + "source": [ + "import getpass\n", + "import os\n", + "\n", + "\n", + "def _set_env(var: str):\n", + " if not os.environ.get(var):\n", + " os.environ[var] = getpass.getpass(f\"{var}: \")\n", + "\n", + "\n", + "_set_env(\"OPENAI_API_KEY\")\n", + "_set_env(\"COHERE_API_KEY\")\n", + "_set_env(\"TAVILY_API_KEY\")" + ] + }, + { + "cell_type": "markdown", + "id": "47e04b18", + "metadata": {}, + "source": [ + "
\n", + "

Set up LangSmith for LangGraph development

\n", + "

\n", + " Sign up for LangSmith to quickly spot issues and improve the performance of your LangGraph projects. LangSmith lets you use trace data to debug, test, and monitor your LLM apps built with LangGraph — read more about how to get started here. \n", + "

\n", + "
" + ] + }, + { + "cell_type": "markdown", + "id": "9ac1c2cd-81fb-40eb-8ba1-e9197800cba6", + "metadata": {}, + "source": [ + "## Create Index" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "b224e5ba-50ca-495a-a7fa-0f75a080e03c", + "metadata": {}, + "outputs": [], + "source": [ + "### Build Index\n", + "\n", + "from langchain.text_splitter import RecursiveCharacterTextSplitter\n", + "from langchain_community.document_loaders import WebBaseLoader\n", + "from langchain_community.vectorstores import Chroma\n", + "from langchain_openai import OpenAIEmbeddings\n", + "\n", + "### from langchain_cohere import CohereEmbeddings\n", + "\n", + "# Set embeddings\n", + "embd = OpenAIEmbeddings()\n", + "\n", + "# Docs to index\n", + "urls = [\n", + " \"https://lilianweng.github.io/posts/2023-06-23-agent/\",\n", + " \"https://lilianweng.github.io/posts/2023-03-15-prompt-engineering/\",\n", + " \"https://lilianweng.github.io/posts/2023-10-25-adv-attack-llm/\",\n", + "]\n", + "\n", + "# Load\n", + "docs = [WebBaseLoader(url).load() for url in urls]\n", + "docs_list = [item for sublist in docs for item in sublist]\n", + "\n", + "# Split\n", + "text_splitter = RecursiveCharacterTextSplitter.from_tiktoken_encoder(\n", + " chunk_size=500, chunk_overlap=0\n", + ")\n", + "doc_splits = text_splitter.split_documents(docs_list)\n", + "\n", + "# Add to vectorstore\n", + "vectorstore = Chroma.from_documents(\n", + " documents=doc_splits,\n", + " collection_name=\"rag-chroma\",\n", + " embedding=embd,\n", + ")\n", + "retriever = vectorstore.as_retriever()" + ] + }, + { + "cell_type": "markdown", + "id": "0f52b427-750c-40f8-8893-e9caab3afd8d", + "metadata": {}, + "source": [ + "## LLMs" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "4dec9d98-f3dc-4b7f-abc0-9d01c754f2be", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "datasource='web_search'\n", + "datasource='vectorstore'\n" + ] + } + ], + "source": [ + "### Router\n", + "\n", + "from typing import Literal\n", + "\n", + "from langchain_core.prompts import ChatPromptTemplate\n", + "from langchain_core.pydantic_v1 import BaseModel, Field\n", + "from langchain_openai import ChatOpenAI\n", + "\n", + "\n", + "# Data model\n", + "class RouteQuery(BaseModel):\n", + " \"\"\"Route a user query to the most relevant datasource.\"\"\"\n", + "\n", + " datasource: Literal[\"vectorstore\", \"web_search\"] = Field(\n", + " ...,\n", + " description=\"Given a user question choose to route it to web search or a vectorstore.\",\n", + " )\n", + "\n", + "\n", + "# LLM with function call\n", + "llm = ChatOpenAI(model=\"gpt-4o-mini\", temperature=0)\n", + "structured_llm_router = llm.with_structured_output(RouteQuery)\n", + "\n", + "# Prompt\n", + "system = \"\"\"You are an expert at routing a user question to a vectorstore or web search.\n", + "The vectorstore contains documents related to agents, prompt engineering, and adversarial attacks.\n", + "Use the vectorstore for questions on these topics. Otherwise, use web-search.\"\"\"\n", + "route_prompt = ChatPromptTemplate.from_messages(\n", + " [\n", + " (\"system\", system),\n", + " (\"human\", \"{question}\"),\n", + " ]\n", + ")\n", + "\n", + "question_router = route_prompt | structured_llm_router\n", + "print(\n", + " question_router.invoke(\n", + " {\"question\": \"Who will the Bears draft first in the NFL draft?\"}\n", + " )\n", + ")\n", + "print(question_router.invoke({\"question\": \"What are the types of agent memory?\"}))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "856801cb-f42a-44e7-956f-47845e3664ca", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "binary_score='no'\n" + ] + } + ], + "source": [ + "### Retrieval Grader\n", + "\n", + "\n", + "# Data model\n", + "class GradeDocuments(BaseModel):\n", + " \"\"\"Binary score for relevance check on retrieved documents.\"\"\"\n", + "\n", + " binary_score: str = Field(\n", + " description=\"Documents are relevant to the question, 'yes' or 'no'\"\n", + " )\n", + "\n", + "\n", + "# LLM with function call\n", + "llm = ChatOpenAI(model=\"gpt-4o-mini\", temperature=0)\n", + "structured_llm_grader = llm.with_structured_output(GradeDocuments)\n", + "\n", + "# Prompt\n", + "system = \"\"\"You are a grader assessing relevance of a retrieved document to a user question. \\n \n", + " If the document contains keyword(s) or semantic meaning related to the user question, grade it as relevant. \\n\n", + " It does not need to be a stringent test. The goal is to filter out erroneous retrievals. \\n\n", + " Give a binary score 'yes' or 'no' score to indicate whether the document is relevant to the question.\"\"\"\n", + "grade_prompt = ChatPromptTemplate.from_messages(\n", + " [\n", + " (\"system\", system),\n", + " (\"human\", \"Retrieved document: \\n\\n {document} \\n\\n User question: {question}\"),\n", + " ]\n", + ")\n", + "\n", + "retrieval_grader = grade_prompt | structured_llm_grader\n", + "question = \"agent memory\"\n", + "docs = retriever.get_relevant_documents(question)\n", + "doc_txt = docs[1].page_content\n", + "print(retrieval_grader.invoke({\"question\": question, \"document\": doc_txt}))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "2272333e-50b2-42ab-b472-e1055a3b94a8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The design of generative agents combines LLM with memory, planning, and reflection mechanisms to enable agents to behave based on past experience and interact with other agents. Memory stream is a long-term memory module that records agents' experiences in natural language. The retrieval model surfaces context to inform the agent's behavior based on relevance, recency, and importance.\n" + ] + } + ], + "source": [ + "### Generate\n", + "\n", + "from langchain import hub\n", + "from langchain_core.output_parsers import StrOutputParser\n", + "\n", + "# Prompt\n", + "prompt = hub.pull(\"rlm/rag-prompt\")\n", + "\n", + "# LLM\n", + "llm = ChatOpenAI(model_name=\"gpt-3.5-turbo\", temperature=0)\n", + "\n", + "\n", + "# Post-processing\n", + "def format_docs(docs):\n", + " return \"\\n\\n\".join(doc.page_content for doc in docs)\n", + "\n", + "\n", + "# Chain\n", + "rag_chain = prompt | llm | StrOutputParser()\n", + "\n", + "# Run\n", + "generation = rag_chain.invoke({\"context\": docs, \"question\": question})\n", + "print(generation)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "f0c08d14-77a0-4eed-b882-2d636abb22a3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "GradeHallucinations(binary_score='yes')" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "### Hallucination Grader\n", + "\n", + "\n", + "# Data model\n", + "class GradeHallucinations(BaseModel):\n", + " \"\"\"Binary score for hallucination present in generation answer.\"\"\"\n", + "\n", + " binary_score: str = Field(\n", + " description=\"Answer is grounded in the facts, 'yes' or 'no'\"\n", + " )\n", + "\n", + "\n", + "# LLM with function call\n", + "llm = ChatOpenAI(model=\"gpt-4o-mini\", temperature=0)\n", + "structured_llm_grader = llm.with_structured_output(GradeHallucinations)\n", + "\n", + "# Prompt\n", + "system = \"\"\"You are a grader assessing whether an LLM generation is grounded in / supported by a set of retrieved facts. \\n \n", + " Give a binary score 'yes' or 'no'. 'Yes' means that the answer is grounded in / supported by the set of facts.\"\"\"\n", + "hallucination_prompt = ChatPromptTemplate.from_messages(\n", + " [\n", + " (\"system\", system),\n", + " (\"human\", \"Set of facts: \\n\\n {documents} \\n\\n LLM generation: {generation}\"),\n", + " ]\n", + ")\n", + "\n", + "hallucination_grader = hallucination_prompt | structured_llm_grader\n", + "hallucination_grader.invoke({\"documents\": docs, \"generation\": generation})" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "ded99680-437a-4c9d-b860-619c88949d84", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "GradeAnswer(binary_score='yes')" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "### Answer Grader\n", + "\n", + "\n", + "# Data model\n", + "class GradeAnswer(BaseModel):\n", + " \"\"\"Binary score to assess answer addresses question.\"\"\"\n", + "\n", + " binary_score: str = Field(\n", + " description=\"Answer addresses the question, 'yes' or 'no'\"\n", + " )\n", + "\n", + "\n", + "# LLM with function call\n", + "llm = ChatOpenAI(model=\"gpt-4o-mini\", temperature=0)\n", + "structured_llm_grader = llm.with_structured_output(GradeAnswer)\n", + "\n", + "# Prompt\n", + "system = \"\"\"You are a grader assessing whether an answer addresses / resolves a question \\n \n", + " Give a binary score 'yes' or 'no'. Yes' means that the answer resolves the question.\"\"\"\n", + "answer_prompt = ChatPromptTemplate.from_messages(\n", + " [\n", + " (\"system\", system),\n", + " (\"human\", \"User question: \\n\\n {question} \\n\\n LLM generation: {generation}\"),\n", + " ]\n", + ")\n", + "\n", + "answer_grader = answer_prompt | structured_llm_grader\n", + "answer_grader.invoke({\"question\": question, \"generation\": generation})" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "9d75f1d7-a47a-4577-bb0d-84b504b0867e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\"What is the role of memory in an agent's functioning?\"" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "### Question Re-writer\n", + "\n", + "# LLM\n", + "llm = ChatOpenAI(model=\"gpt-3.5-turbo-0125\", temperature=0)\n", + "\n", + "# Prompt\n", + "system = \"\"\"You a question re-writer that converts an input question to a better version that is optimized \\n \n", + " for vectorstore retrieval. Look at the input and try to reason about the underlying semantic intent / meaning.\"\"\"\n", + "re_write_prompt = ChatPromptTemplate.from_messages(\n", + " [\n", + " (\"system\", system),\n", + " (\n", + " \"human\",\n", + " \"Here is the initial question: \\n\\n {question} \\n Formulate an improved question.\",\n", + " ),\n", + " ]\n", + ")\n", + "\n", + "question_rewriter = re_write_prompt | llm | StrOutputParser()\n", + "question_rewriter.invoke({\"question\": question})" + ] + }, + { + "cell_type": "markdown", + "id": "d07c0b31-b919-4498-869f-9673125c2473", + "metadata": {}, + "source": [ + "## Web Search Tool" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "01d829bb-1074-4976-b650-ead41dcb9788", + "metadata": {}, + "outputs": [], + "source": [ + "### Search\n", + "\n", + "from langchain_community.tools.tavily_search import TavilySearchResults\n", + "\n", + "web_search_tool = TavilySearchResults(k=3)" + ] + }, + { + "cell_type": "markdown", + "id": "efbbff0e-8843-45bb-b2ff-137bef707ef4", + "metadata": {}, + "source": [ + "## Construct the Graph \n", + "\n", + "Capture the flow in as a graph.\n", + "\n", + "### Define Graph State" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "e723fcdb-06e6-402d-912e-899795b78408", + "metadata": {}, + "outputs": [], + "source": [ + "from typing import List\n", + "\n", + "from typing_extensions import TypedDict\n", + "\n", + "\n", + "class GraphState(TypedDict):\n", + " \"\"\"\n", + " Represents the state of our graph.\n", + "\n", + " Attributes:\n", + " question: question\n", + " generation: LLM generation\n", + " documents: list of documents\n", + " \"\"\"\n", + "\n", + " question: str\n", + " generation: str\n", + " documents: List[str]" + ] + }, + { + "cell_type": "markdown", + "id": "7e2d6c0d-42e8-4399-9751-e315be16607a", + "metadata": {}, + "source": [ + "### Define Graph Flow " + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "b76b5ec3-0720-443d-85b1-c0e79659ca0a", + "metadata": {}, + "outputs": [], + "source": [ + "from langchain.schema import Document\n", + "\n", + "\n", + "def retrieve(state):\n", + " \"\"\"\n", + " Retrieve documents\n", + "\n", + " Args:\n", + " state (dict): The current graph state\n", + "\n", + " Returns:\n", + " state (dict): New key added to state, documents, that contains retrieved documents\n", + " \"\"\"\n", + " print(\"---RETRIEVE---\")\n", + " question = state[\"question\"]\n", + "\n", + " # Retrieval\n", + " documents = retriever.invoke(question)\n", + " return {\"documents\": documents, \"question\": question}\n", + "\n", + "\n", + "def generate(state):\n", + " \"\"\"\n", + " Generate answer\n", + "\n", + " Args:\n", + " state (dict): The current graph state\n", + "\n", + " Returns:\n", + " state (dict): New key added to state, generation, that contains LLM generation\n", + " \"\"\"\n", + " print(\"---GENERATE---\")\n", + " question = state[\"question\"]\n", + " documents = state[\"documents\"]\n", + "\n", + " # RAG generation\n", + " generation = rag_chain.invoke({\"context\": documents, \"question\": question})\n", + " return {\"documents\": documents, \"question\": question, \"generation\": generation}\n", + "\n", + "\n", + "def grade_documents(state):\n", + " \"\"\"\n", + " Determines whether the retrieved documents are relevant to the question.\n", + "\n", + " Args:\n", + " state (dict): The current graph state\n", + "\n", + " Returns:\n", + " state (dict): Updates documents key with only filtered relevant documents\n", + " \"\"\"\n", + "\n", + " print(\"---CHECK DOCUMENT RELEVANCE TO QUESTION---\")\n", + " question = state[\"question\"]\n", + " documents = state[\"documents\"]\n", + "\n", + " # Score each doc\n", + " filtered_docs = []\n", + " for d in documents:\n", + " score = retrieval_grader.invoke(\n", + " {\"question\": question, \"document\": d.page_content}\n", + " )\n", + " grade = score.binary_score\n", + " if grade == \"yes\":\n", + " print(\"---GRADE: DOCUMENT RELEVANT---\")\n", + " filtered_docs.append(d)\n", + " else:\n", + " print(\"---GRADE: DOCUMENT NOT RELEVANT---\")\n", + " continue\n", + " return {\"documents\": filtered_docs, \"question\": question}\n", + "\n", + "\n", + "def transform_query(state):\n", + " \"\"\"\n", + " Transform the query to produce a better question.\n", + "\n", + " Args:\n", + " state (dict): The current graph state\n", + "\n", + " Returns:\n", + " state (dict): Updates question key with a re-phrased question\n", + " \"\"\"\n", + "\n", + " print(\"---TRANSFORM QUERY---\")\n", + " question = state[\"question\"]\n", + " documents = state[\"documents\"]\n", + "\n", + " # Re-write question\n", + " better_question = question_rewriter.invoke({\"question\": question})\n", + " return {\"documents\": documents, \"question\": better_question}\n", + "\n", + "\n", + "def web_search(state):\n", + " \"\"\"\n", + " Web search based on the re-phrased question.\n", + "\n", + " Args:\n", + " state (dict): The current graph state\n", + "\n", + " Returns:\n", + " state (dict): Updates documents key with appended web results\n", + " \"\"\"\n", + "\n", + " print(\"---WEB SEARCH---\")\n", + " question = state[\"question\"]\n", + "\n", + " # Web search\n", + " docs = web_search_tool.invoke({\"query\": question})\n", + " web_results = \"\\n\".join([d[\"content\"] for d in docs])\n", + " web_results = Document(page_content=web_results)\n", + "\n", + " return {\"documents\": web_results, \"question\": question}\n", + "\n", + "\n", + "### Edges ###\n", + "\n", + "\n", + "def route_question(state):\n", + " \"\"\"\n", + " Route question to web search or RAG.\n", + "\n", + " Args:\n", + " state (dict): The current graph state\n", + "\n", + " Returns:\n", + " str: Next node to call\n", + " \"\"\"\n", + "\n", + " print(\"---ROUTE QUESTION---\")\n", + " question = state[\"question\"]\n", + " source = question_router.invoke({\"question\": question})\n", + " if source.datasource == \"web_search\":\n", + " print(\"---ROUTE QUESTION TO WEB SEARCH---\")\n", + " return \"web_search\"\n", + " elif source.datasource == \"vectorstore\":\n", + " print(\"---ROUTE QUESTION TO RAG---\")\n", + " return \"vectorstore\"\n", + "\n", + "\n", + "def decide_to_generate(state):\n", + " \"\"\"\n", + " Determines whether to generate an answer, or re-generate a question.\n", + "\n", + " Args:\n", + " state (dict): The current graph state\n", + "\n", + " Returns:\n", + " str: Binary decision for next node to call\n", + " \"\"\"\n", + "\n", + " print(\"---ASSESS GRADED DOCUMENTS---\")\n", + " state[\"question\"]\n", + " filtered_documents = state[\"documents\"]\n", + "\n", + " if not filtered_documents:\n", + " # All documents have been filtered check_relevance\n", + " # We will re-generate a new query\n", + " print(\n", + " \"---DECISION: ALL DOCUMENTS ARE NOT RELEVANT TO QUESTION, TRANSFORM QUERY---\"\n", + " )\n", + " return \"transform_query\"\n", + " else:\n", + " # We have relevant documents, so generate answer\n", + " print(\"---DECISION: GENERATE---\")\n", + " return \"generate\"\n", + "\n", + "\n", + "def grade_generation_v_documents_and_question(state):\n", + " \"\"\"\n", + " Determines whether the generation is grounded in the document and answers question.\n", + "\n", + " Args:\n", + " state (dict): The current graph state\n", + "\n", + " Returns:\n", + " str: Decision for next node to call\n", + " \"\"\"\n", + "\n", + " print(\"---CHECK HALLUCINATIONS---\")\n", + " question = state[\"question\"]\n", + " documents = state[\"documents\"]\n", + " generation = state[\"generation\"]\n", + "\n", + " score = hallucination_grader.invoke(\n", + " {\"documents\": documents, \"generation\": generation}\n", + " )\n", + " grade = score.binary_score\n", + "\n", + " # Check hallucination\n", + " if grade == \"yes\":\n", + " print(\"---DECISION: GENERATION IS GROUNDED IN DOCUMENTS---\")\n", + " # Check question-answering\n", + " print(\"---GRADE GENERATION vs QUESTION---\")\n", + " score = answer_grader.invoke({\"question\": question, \"generation\": generation})\n", + " grade = score.binary_score\n", + " if grade == \"yes\":\n", + " print(\"---DECISION: GENERATION ADDRESSES QUESTION---\")\n", + " return \"useful\"\n", + " else:\n", + " print(\"---DECISION: GENERATION DOES NOT ADDRESS QUESTION---\")\n", + " return \"not useful\"\n", + " else:\n", + " pprint(\"---DECISION: GENERATION IS NOT GROUNDED IN DOCUMENTS, RE-TRY---\")\n", + " return \"not supported\"" + ] + }, + { + "cell_type": "markdown", + "id": "3ab01f36-5628-49ab-bfd3-84bb6f1a1b0f", + "metadata": {}, + "source": [ + "### Compile Graph" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "67854e07-9293-4c3c-bf9a-bc9a605570ee", + "metadata": {}, + "outputs": [], + "source": [ + "from langgraph.graph import END, StateGraph, START\n", + "\n", + "workflow = StateGraph(GraphState)\n", + "\n", + "# Define the nodes\n", + "workflow.add_node(\"web_search\", web_search) # web search\n", + "workflow.add_node(\"retrieve\", retrieve) # retrieve\n", + "workflow.add_node(\"grade_documents\", grade_documents) # grade documents\n", + "workflow.add_node(\"generate\", generate) # generate\n", + "workflow.add_node(\"transform_query\", transform_query) # transform_query\n", + "\n", + "# Build graph\n", + "workflow.add_conditional_edges(\n", + " START,\n", + " route_question,\n", + " {\n", + " \"web_search\": \"web_search\",\n", + " \"vectorstore\": \"retrieve\",\n", + " },\n", + ")\n", + "workflow.add_edge(\"web_search\", \"generate\")\n", + "workflow.add_edge(\"retrieve\", \"grade_documents\")\n", + "workflow.add_conditional_edges(\n", + " \"grade_documents\",\n", + " decide_to_generate,\n", + " {\n", + " \"transform_query\": \"transform_query\",\n", + " \"generate\": \"generate\",\n", + " },\n", + ")\n", + "workflow.add_edge(\"transform_query\", \"retrieve\")\n", + "workflow.add_conditional_edges(\n", + " \"generate\",\n", + " grade_generation_v_documents_and_question,\n", + " {\n", + " \"not supported\": \"generate\",\n", + " \"useful\": END,\n", + " \"not useful\": \"transform_query\",\n", + " },\n", + ")\n", + "\n", + "# Compile\n", + "app = workflow.compile()" + ] + }, + { + "cell_type": "markdown", + "id": "85bce541", + "metadata": {}, + "source": [ + "## Use Graph" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "29acc541-d726-4b75-84d1-a215845fe88a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---ROUTE QUESTION---\n", + "---ROUTE QUESTION TO WEB SEARCH---\n", + "---WEB SEARCH---\n", + "\"Node 'web_search':\"\n", + "'\\n---\\n'\n", + "---GENERATE---\n", + "---CHECK HALLUCINATIONS---\n", + "---DECISION: GENERATION IS GROUNDED IN DOCUMENTS---\n", + "---GRADE GENERATION vs QUESTION---\n", + "---DECISION: GENERATION ADDRESSES QUESTION---\n", + "\"Node 'generate':\"\n", + "'\\n---\\n'\n", + "('It is expected that the Chicago Bears could have the opportunity to draft '\n", + " 'the first defensive player in the 2024 NFL draft. The Bears have the first '\n", + " 'overall pick in the draft, giving them a prime position to select top '\n", + " 'talent. The top wide receiver Marvin Harrison Jr. from Ohio State is also '\n", + " 'mentioned as a potential pick for the Cardinals.')\n" + ] + } + ], + "source": [ + "from pprint import pprint\n", + "\n", + "# Run\n", + "inputs = {\n", + " \"question\": \"What player at the Bears expected to draft first in the 2024 NFL draft?\"\n", + "}\n", + "for output in app.stream(inputs):\n", + " for key, value in output.items():\n", + " # Node\n", + " pprint(f\"Node '{key}':\")\n", + " # Optional: print full state at each node\n", + " # pprint.pprint(value[\"keys\"], indent=2, width=80, depth=None)\n", + " pprint(\"\\n---\\n\")\n", + "\n", + "# Final generation\n", + "pprint(value[\"generation\"])" + ] + }, + { + "cell_type": "markdown", + "id": "11fddd00-58bf-4910-bf36-be9e5bfba778", + "metadata": {}, + "source": [ + "Trace: \n", + "\n", + "https://smith.langchain.com/public/7e3aa7e5-c51f-45c2-bc66-b34f17ff2263/r" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "69a985dd-03c6-45af-a67b-b15746a2cb5f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---ROUTE QUESTION---\n", + "---ROUTE QUESTION TO RAG---\n", + "---RETRIEVE---\n", + "\"Node 'retrieve':\"\n", + "'\\n---\\n'\n", + "---CHECK DOCUMENT RELEVANCE TO QUESTION---\n", + "---GRADE: DOCUMENT RELEVANT---\n", + "---GRADE: DOCUMENT RELEVANT---\n", + "---GRADE: DOCUMENT NOT RELEVANT---\n", + "---GRADE: DOCUMENT RELEVANT---\n", + "---ASSESS GRADED DOCUMENTS---\n", + "---DECISION: GENERATE---\n", + "\"Node 'grade_documents':\"\n", + "'\\n---\\n'\n", + "---GENERATE---\n", + "---CHECK HALLUCINATIONS---\n", + "---DECISION: GENERATION IS GROUNDED IN DOCUMENTS---\n", + "---GRADE GENERATION vs QUESTION---\n", + "---DECISION: GENERATION ADDRESSES QUESTION---\n", + "\"Node 'generate':\"\n", + "'\\n---\\n'\n", + "('The types of agent memory include Sensory Memory, Short-Term Memory (STM) or '\n", + " 'Working Memory, and Long-Term Memory (LTM) with subtypes of Explicit / '\n", + " 'declarative memory and Implicit / procedural memory. Sensory memory retains '\n", + " 'sensory information briefly, STM stores information for cognitive tasks, and '\n", + " 'LTM stores information for a long time with different types of memories.')\n" + ] + } + ], + "source": [ + "# Run\n", + "inputs = {\"question\": \"What are the types of agent memory?\"}\n", + "for output in app.stream(inputs):\n", + " for key, value in output.items():\n", + " # Node\n", + " pprint(f\"Node '{key}':\")\n", + " # Optional: print full state at each node\n", + " # pprint.pprint(value[\"keys\"], indent=2, width=80, depth=None)\n", + " pprint(\"\\n---\\n\")\n", + "\n", + "# Final generation\n", + "pprint(value[\"generation\"])" + ] + }, + { + "cell_type": "markdown", + "id": "ebf41097-fc4c-4072-95b3-e7e07731ada1", + "metadata": {}, + "source": [ + "Trace: \n", + "\n", + "https://smith.langchain.com/public/fdf0a180-6d15-4d09-bb92-f84f2105ca51/r" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/rag/langgraph_adaptive_rag_cohere.ipynb b/examples/rag/langgraph_adaptive_rag_cohere.ipynb new file mode 100644 index 000000000..dbc957f91 --- /dev/null +++ b/examples/rag/langgraph_adaptive_rag_cohere.ipynb @@ -0,0 +1,597 @@ +{ + "cells": [ + { + "attachments": { + "2a4ecdd2-280d-4311-a2cd-cd6138090be9.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "5afcaed0-3d55-4e1f-95d3-c32c751c29d8", + "metadata": { + "id": "5afcaed0-3d55-4e1f-95d3-c32c751c29d8" + }, + "source": [ + "# Adaptive RAG Cohere Command R\n", + "\n", + "Adaptive RAG is a strategy for RAG that unites (1) [query analysis](https://blog.langchain.dev/query-construction/) with (2) [active / self-corrective RAG](https://blog.langchain.dev/agentic-rag-with-langgraph/).\n", + "\n", + "In the paper, they report query analysis to route across:\n", + "\n", + "* No Retrieval (LLM answers)\n", + "* Single-shot RAG\n", + "* Iterative RAG\n", + "\n", + "Let's build on this to perform query analysis to route across some more interesting cases:\n", + "\n", + "* No Retrieval (LLM answers)\n", + "* Web-search\n", + "* Iterative RAG\n", + "\n", + "We'll use [Command R](https://cohere.com/blog/command-r), a recent release from Cohere that:\n", + "\n", + "* Has strong accuracy on RAG and Tool Use\n", + "* Has 128k context\n", + "* Has low latency \n", + " \n", + "![Screenshot 2024-04-02 at 8.11.18 PM.png](attachment:2a4ecdd2-280d-4311-a2cd-cd6138090be9.png)" + ] + }, + { + "cell_type": "markdown", + "id": "a85501ca-eb89-4795-aeab-cdab050ead6b", + "metadata": { + "id": "a85501ca-eb89-4795-aeab-cdab050ead6b" + }, + "source": [ + "# Environment" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f6c329ba-cb85-4576-9828-4f2ac648d1a6", + "metadata": {}, + "outputs": [], + "source": [ + "! pip install --quiet langchain langchain_cohere langchain-openai tiktoken langchainhub chromadb langgraph" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "222f204d-956f-4128-b597-2c698120edda", + "metadata": { + "id": "222f204d-956f-4128-b597-2c698120edda" + }, + "outputs": [], + "source": [ + "### LLMs\nimport os\n\nos.environ[\"COHERE_API_KEY\"] = \"\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "08edba00-988a-478b-96fc-ae0199cbef49", + "metadata": { + "id": "08edba00-988a-478b-96fc-ae0199cbef49" + }, + "outputs": [], + "source": [ + "# ### Tracing (optional)\n# os.environ['LANGCHAIN_TRACING_V2'] = 'true'\n# os.environ['LANGCHAIN_ENDPOINT'] = 'https://api.smith.langchain.com'\n# os.environ['LANGCHAIN_API_KEY'] =''" + ] + }, + { + "cell_type": "markdown", + "id": "9ac1c2cd-81fb-40eb-8ba1-e9197800cba6", + "metadata": { + "id": "9ac1c2cd-81fb-40eb-8ba1-e9197800cba6" + }, + "source": [ + "## Index" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "b224e5ba-50ca-495a-a7fa-0f75a080e03c", + "metadata": { + "id": "b224e5ba-50ca-495a-a7fa-0f75a080e03c" + }, + "outputs": [], + "source": [ + "### Build Index\n\nfrom langchain.text_splitter import RecursiveCharacterTextSplitter\nfrom langchain_cohere import CohereEmbeddings\nfrom langchain_community.document_loaders import WebBaseLoader\nfrom langchain_community.vectorstores import Chroma\n\n# Set embeddings\nembd = CohereEmbeddings()\n\n# Docs to index\nurls = [\n \"https://lilianweng.github.io/posts/2023-06-23-agent/\",\n \"https://lilianweng.github.io/posts/2023-03-15-prompt-engineering/\",\n \"https://lilianweng.github.io/posts/2023-10-25-adv-attack-llm/\",\n]\n\n# Load\ndocs = [WebBaseLoader(url).load() for url in urls]\ndocs_list = [item for sublist in docs for item in sublist]\n\n# Split\ntext_splitter = RecursiveCharacterTextSplitter.from_tiktoken_encoder(\n chunk_size=512, chunk_overlap=0\n)\ndoc_splits = text_splitter.split_documents(docs_list)\n\n# Add to vectorstore\nvectorstore = Chroma.from_documents(\n documents=doc_splits,\n embedding=embd,\n)\n\nretriever = vectorstore.as_retriever()" + ] + }, + { + "cell_type": "markdown", + "id": "0f52b427-750c-40f8-8893-e9caab3afd8d", + "metadata": { + "id": "0f52b427-750c-40f8-8893-e9caab3afd8d" + }, + "source": [ + "## LLMs" + ] + }, + { + "cell_type": "markdown", + "id": "H5CztTqsBOTZ", + "metadata": { + "id": "H5CztTqsBOTZ" + }, + "source": [ + "We use a router to pick between tools. \n", + " \n", + "Cohere model decides which tool(s) to call, as well as the how to query them." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "bYK-e0diGdPf", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "bYK-e0diGdPf", + "outputId": "895a8ea5-57ee-49fe-ef28-277eac8a7bb7" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[{'id': 'f811e3b9-052e-49db-a234-5fc3efbcc5ba', 'function': {'name': 'web_search', 'arguments': '{\"query\": \"NFL draft bears first pick\"}'}, 'type': 'function'}]\n", + "[{'id': '4bc53113-8f32-4d6d-ac9b-c07ef9aae9fd', 'function': {'name': 'vectorstore', 'arguments': '{\"query\": \"types of agent memory\"}'}, 'type': 'function'}]\n", + "False\n" + ] + } + ], + "source": [ + "### Router\n\nfrom langchain_cohere import ChatCohere\nfrom langchain_core.prompts import ChatPromptTemplate\nfrom langchain_core.pydantic_v1 import BaseModel, Field\n\n\n# Data model\nclass web_search(BaseModel):\n \"\"\"\n The internet. Use web_search for questions that are related to anything else than agents, prompt engineering, and adversarial attacks.\n \"\"\"\n\n query: str = Field(description=\"The query to use when searching the internet.\")\n\n\nclass vectorstore(BaseModel):\n \"\"\"\n A vectorstore containing documents related to agents, prompt engineering, and adversarial attacks. Use the vectorstore for questions on these topics.\n \"\"\"\n\n query: str = Field(description=\"The query to use when searching the vectorstore.\")\n\n\n# Preamble\npreamble = \"\"\"You are an expert at routing a user question to a vectorstore or web search.\nThe vectorstore contains documents related to agents, prompt engineering, and adversarial attacks.\nUse the vectorstore for questions on these topics. Otherwise, use web-search.\"\"\"\n\n# LLM with tool use and preamble\nllm = ChatCohere(model=\"command-r\", temperature=0)\nstructured_llm_router = llm.bind_tools(\n tools=[web_search, vectorstore], preamble=preamble\n)\n\n# Prompt\nroute_prompt = ChatPromptTemplate.from_messages(\n [\n (\"human\", \"{question}\"),\n ]\n)\n\nquestion_router = route_prompt | structured_llm_router\nresponse = question_router.invoke(\n {\"question\": \"Who will the Bears draft first in the NFL draft?\"}\n)\nprint(response.response_metadata[\"tool_calls\"])\nresponse = question_router.invoke({\"question\": \"What are the types of agent memory?\"})\nprint(response.response_metadata[\"tool_calls\"])\nresponse = question_router.invoke({\"question\": \"Hi how are you?\"})\nprint(\"tool_calls\" in response.response_metadata)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "oaLWNbWxBgjE", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "oaLWNbWxBgjE", + "outputId": "57a5c27b-044b-4df5-f55d-7bf23d3976d1" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "binary_score='yes'\n" + ] + } + ], + "source": [ + "### Retrieval Grader\n\n\n# Data model\nclass GradeDocuments(BaseModel):\n \"\"\"Binary score for relevance check on retrieved documents.\"\"\"\n\n binary_score: str = Field(\n description=\"Documents are relevant to the question, 'yes' or 'no'\"\n )\n\n\n# Prompt\npreamble = \"\"\"You are a grader assessing relevance of a retrieved document to a user question. \\n\nIf the document contains keyword(s) or semantic meaning related to the user question, grade it as relevant. \\n\nGive a binary score 'yes' or 'no' score to indicate whether the document is relevant to the question.\"\"\"\n\n# LLM with function call\nllm = ChatCohere(model=\"command-r\", temperature=0)\nstructured_llm_grader = llm.with_structured_output(GradeDocuments, preamble=preamble)\n\ngrade_prompt = ChatPromptTemplate.from_messages(\n [\n (\"human\", \"Retrieved document: \\n\\n {document} \\n\\n User question: {question}\"),\n ]\n)\n\nretrieval_grader = grade_prompt | structured_llm_grader\nquestion = \"types of agent memory\"\ndocs = retriever.invoke(question)\ndoc_txt = docs[1].page_content\nresponse = retrieval_grader.invoke({\"question\": question, \"document\": doc_txt})\nprint(response)" + ] + }, + { + "cell_type": "markdown", + "id": "D43a7vM4EElX", + "metadata": { + "id": "D43a7vM4EElX" + }, + "source": [ + "Generate" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "BTIUdjRMEq_h", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "BTIUdjRMEq_h", + "outputId": "11a99f62-2449-45db-9281-5bfd60e3c966" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "There are three types of agent memory: sensory memory, short-term memory, and long-term memory.\n" + ] + } + ], + "source": [ + "### Generate\n\nfrom langchain_core.messages import HumanMessage\nfrom langchain_core.output_parsers import StrOutputParser\n\n# Preamble\npreamble = \"\"\"You are an assistant for question-answering tasks. Use the following pieces of retrieved context to answer the question. If you don't know the answer, just say that you don't know. Use three sentences maximum and keep the answer concise.\"\"\"\n\n# LLM\nllm = ChatCohere(model_name=\"command-r\", temperature=0).bind(preamble=preamble)\n\n\n# Prompt\ndef prompt(x):\n return ChatPromptTemplate.from_messages(\n [\n HumanMessage(\n f\"Question: {x['question']} \\nAnswer: \",\n additional_kwargs={\"documents\": x[\"documents\"]},\n )\n ]\n )\n\n\n# Chain\nrag_chain = prompt | llm | StrOutputParser()\n\n# Run\ngeneration = rag_chain.invoke({\"documents\": docs, \"question\": question})\nprint(generation)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "bc000a7d-84b6-4eb2-88ad-65cc62a44431", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "I don't have feelings as an AI chatbot, but I'm here to assist you with any queries or concerns you may have. How can I help you today?\n" + ] + } + ], + "source": [ + "### LLM fallback\n\nfrom langchain_core.output_parsers import StrOutputParser\n\n# Preamble\npreamble = \"\"\"You are an assistant for question-answering tasks. Answer the question based upon your knowledge. Use three sentences maximum and keep the answer concise.\"\"\"\n\n# LLM\nllm = ChatCohere(model_name=\"command-r\", temperature=0).bind(preamble=preamble)\n\n\n# Prompt\ndef prompt(x):\n return ChatPromptTemplate.from_messages(\n [HumanMessage(f\"Question: {x['question']} \\nAnswer: \")]\n )\n\n\n# Chain\nllm_chain = prompt | llm | StrOutputParser()\n\n# Run\nquestion = \"Hi how are you?\"\ngeneration = llm_chain.invoke({\"question\": question})\nprint(generation)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "y0msuR2DHQkY", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "y0msuR2DHQkY", + "outputId": "f0e91c2a-5542-45c0-a7a6-60453e0b2bc4" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "GradeHallucinations(binary_score='yes')" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "### Hallucination Grader\n\n\n# Data model\nclass GradeHallucinations(BaseModel):\n \"\"\"Binary score for hallucination present in generation answer.\"\"\"\n\n binary_score: str = Field(\n description=\"Answer is grounded in the facts, 'yes' or 'no'\"\n )\n\n\n# Preamble\npreamble = \"\"\"You are a grader assessing whether an LLM generation is grounded in / supported by a set of retrieved facts. \\n\nGive a binary score 'yes' or 'no'. 'Yes' means that the answer is grounded in / supported by the set of facts.\"\"\"\n\n# LLM with function call\nllm = ChatCohere(model=\"command-r\", temperature=0)\nstructured_llm_grader = llm.with_structured_output(\n GradeHallucinations, preamble=preamble\n)\n\n# Prompt\nhallucination_prompt = ChatPromptTemplate.from_messages(\n [\n # (\"system\", system),\n (\"human\", \"Set of facts: \\n\\n {documents} \\n\\n LLM generation: {generation}\"),\n ]\n)\n\nhallucination_grader = hallucination_prompt | structured_llm_grader\nhallucination_grader.invoke({\"documents\": docs, \"generation\": generation})" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "f0c08d14-77a0-4eed-b882-2d636abb22a3", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "f0c08d14-77a0-4eed-b882-2d636abb22a3", + "outputId": "c4f88c9a-65fd-4dad-e739-3c9bd547a9f5" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "GradeAnswer(binary_score='yes')" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "### Answer Grader\n\n\n# Data model\nclass GradeAnswer(BaseModel):\n \"\"\"Binary score to assess answer addresses question.\"\"\"\n\n binary_score: str = Field(\n description=\"Answer addresses the question, 'yes' or 'no'\"\n )\n\n\n# Preamble\npreamble = \"\"\"You are a grader assessing whether an answer addresses / resolves a question \\n\nGive a binary score 'yes' or 'no'. Yes' means that the answer resolves the question.\"\"\"\n\n# LLM with function call\nllm = ChatCohere(model=\"command-r\", temperature=0)\nstructured_llm_grader = llm.with_structured_output(GradeAnswer, preamble=preamble)\n\n# Prompt\nanswer_prompt = ChatPromptTemplate.from_messages(\n [\n (\"human\", \"User question: \\n\\n {question} \\n\\n LLM generation: {generation}\"),\n ]\n)\n\nanswer_grader = answer_prompt | structured_llm_grader\nanswer_grader.invoke({\"question\": question, \"generation\": generation})" + ] + }, + { + "cell_type": "markdown", + "id": "d07c0b31-b919-4498-869f-9673125c2473", + "metadata": { + "id": "d07c0b31-b919-4498-869f-9673125c2473" + }, + "source": [ + "## Web Search Tool" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "01d829bb-1074-4976-b650-ead41dcb9788", + "metadata": { + "id": "01d829bb-1074-4976-b650-ead41dcb9788" + }, + "outputs": [], + "source": [ + "### Search\n# os.environ['TAVILY_API_KEY'] =''\n\nfrom langchain_community.tools.tavily_search import TavilySearchResults\n\nweb_search_tool = TavilySearchResults()" + ] + }, + { + "cell_type": "markdown", + "id": "efbbff0e-8843-45bb-b2ff-137bef707ef4", + "metadata": { + "id": "efbbff0e-8843-45bb-b2ff-137bef707ef4" + }, + "source": [ + "# Graph\n", + "\n", + "Capture the flow in as a graph.\n", + "\n", + "## Graph state" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "e723fcdb-06e6-402d-912e-899795b78408", + "metadata": { + "id": "e723fcdb-06e6-402d-912e-899795b78408" + }, + "outputs": [], + "source": [ + "from typing import List\n\nfrom typing_extensions import TypedDict\n\n\nclass GraphState(TypedDict):\n \"\"\"|\n Represents the state of our graph.\n\n Attributes:\n question: question\n generation: LLM generation\n documents: list of documents\n \"\"\"\n\n question: str\n generation: str\n documents: List[str]" + ] + }, + { + "cell_type": "markdown", + "id": "7e2d6c0d-42e8-4399-9751-e315be16607a", + "metadata": { + "id": "7e2d6c0d-42e8-4399-9751-e315be16607a" + }, + "source": [ + "## Graph Flow" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "b76b5ec3-0720-443d-85b1-c0e79659ca0a", + "metadata": { + "id": "b76b5ec3-0720-443d-85b1-c0e79659ca0a" + }, + "outputs": [], + "source": [ + "from langchain.schema import Document\n\n\ndef retrieve(state):\n \"\"\"\n Retrieve documents\n\n Args:\n state (dict): The current graph state\n\n Returns:\n state (dict): New key added to state, documents, that contains retrieved documents\n \"\"\"\n print(\"---RETRIEVE---\")\n question = state[\"question\"]\n\n # Retrieval\n documents = retriever.invoke(question)\n return {\"documents\": documents, \"question\": question}\n\n\ndef llm_fallback(state):\n \"\"\"\n Generate answer using the LLM w/o vectorstore\n\n Args:\n state (dict): The current graph state\n\n Returns:\n state (dict): New key added to state, generation, that contains LLM generation\n \"\"\"\n print(\"---LLM Fallback---\")\n question = state[\"question\"]\n generation = llm_chain.invoke({\"question\": question})\n return {\"question\": question, \"generation\": generation}\n\n\ndef generate(state):\n \"\"\"\n Generate answer using the vectorstore\n\n Args:\n state (dict): The current graph state\n\n Returns:\n state (dict): New key added to state, generation, that contains LLM generation\n \"\"\"\n print(\"---GENERATE---\")\n question = state[\"question\"]\n documents = state[\"documents\"]\n if not isinstance(documents, list):\n documents = [documents]\n\n # RAG generation\n generation = rag_chain.invoke({\"documents\": documents, \"question\": question})\n return {\"documents\": documents, \"question\": question, \"generation\": generation}\n\n\ndef grade_documents(state):\n \"\"\"\n Determines whether the retrieved documents are relevant to the question.\n\n Args:\n state (dict): The current graph state\n\n Returns:\n state (dict): Updates documents key with only filtered relevant documents\n \"\"\"\n\n print(\"---CHECK DOCUMENT RELEVANCE TO QUESTION---\")\n question = state[\"question\"]\n documents = state[\"documents\"]\n\n # Score each doc\n filtered_docs = []\n for d in documents:\n score = retrieval_grader.invoke(\n {\"question\": question, \"document\": d.page_content}\n )\n grade = score.binary_score\n if grade == \"yes\":\n print(\"---GRADE: DOCUMENT RELEVANT---\")\n filtered_docs.append(d)\n else:\n print(\"---GRADE: DOCUMENT NOT RELEVANT---\")\n continue\n return {\"documents\": filtered_docs, \"question\": question}\n\n\ndef web_search(state):\n \"\"\"\n Web search based on the re-phrased question.\n\n Args:\n state (dict): The current graph state\n\n Returns:\n state (dict): Updates documents key with appended web results\n \"\"\"\n\n print(\"---WEB SEARCH---\")\n question = state[\"question\"]\n\n # Web search\n docs = web_search_tool.invoke({\"query\": question})\n web_results = \"\\n\".join([d[\"content\"] for d in docs])\n web_results = Document(page_content=web_results)\n\n return {\"documents\": web_results, \"question\": question}\n\n\n### Edges ###\n\n\ndef route_question(state):\n \"\"\"\n Route question to web search or RAG.\n\n Args:\n state (dict): The current graph state\n\n Returns:\n str: Next node to call\n \"\"\"\n\n print(\"---ROUTE QUESTION---\")\n question = state[\"question\"]\n source = question_router.invoke({\"question\": question})\n\n # Fallback to LLM or raise error if no decision\n if \"tool_calls\" not in source.additional_kwargs:\n print(\"---ROUTE QUESTION TO LLM---\")\n return \"llm_fallback\"\n if len(source.additional_kwargs[\"tool_calls\"]) == 0:\n raise \"Router could not decide source\"\n\n # Choose datasource\n datasource = source.additional_kwargs[\"tool_calls\"][0][\"function\"][\"name\"]\n if datasource == \"web_search\":\n print(\"---ROUTE QUESTION TO WEB SEARCH---\")\n return \"web_search\"\n elif datasource == \"vectorstore\":\n print(\"---ROUTE QUESTION TO RAG---\")\n return \"vectorstore\"\n else:\n print(\"---ROUTE QUESTION TO LLM---\")\n return \"vectorstore\"\n\n\ndef decide_to_generate(state):\n \"\"\"\n Determines whether to generate an answer, or re-generate a question.\n\n Args:\n state (dict): The current graph state\n\n Returns:\n str: Binary decision for next node to call\n \"\"\"\n\n print(\"---ASSESS GRADED DOCUMENTS---\")\n state[\"question\"]\n filtered_documents = state[\"documents\"]\n\n if not filtered_documents:\n # All documents have been filtered check_relevance\n # We will re-generate a new query\n print(\"---DECISION: ALL DOCUMENTS ARE NOT RELEVANT TO QUESTION, WEB SEARCH---\")\n return \"web_search\"\n else:\n # We have relevant documents, so generate answer\n print(\"---DECISION: GENERATE---\")\n return \"generate\"\n\n\ndef grade_generation_v_documents_and_question(state):\n \"\"\"\n Determines whether the generation is grounded in the document and answers question.\n\n Args:\n state (dict): The current graph state\n\n Returns:\n str: Decision for next node to call\n \"\"\"\n\n print(\"---CHECK HALLUCINATIONS---\")\n question = state[\"question\"]\n documents = state[\"documents\"]\n generation = state[\"generation\"]\n\n score = hallucination_grader.invoke(\n {\"documents\": documents, \"generation\": generation}\n )\n grade = score.binary_score\n\n # Check hallucination\n if grade == \"yes\":\n print(\"---DECISION: GENERATION IS GROUNDED IN DOCUMENTS---\")\n # Check question-answering\n print(\"---GRADE GENERATION vs QUESTION---\")\n score = answer_grader.invoke({\"question\": question, \"generation\": generation})\n grade = score.binary_score\n if grade == \"yes\":\n print(\"---DECISION: GENERATION ADDRESSES QUESTION---\")\n return \"useful\"\n else:\n print(\"---DECISION: GENERATION DOES NOT ADDRESS QUESTION---\")\n return \"not useful\"\n else:\n pprint(\"---DECISION: GENERATION IS NOT GROUNDED IN DOCUMENTS, RE-TRY---\")\n return \"not supported\"" + ] + }, + { + "cell_type": "markdown", + "id": "3ab01f36-5628-49ab-bfd3-84bb6f1a1b0f", + "metadata": { + "id": "3ab01f36-5628-49ab-bfd3-84bb6f1a1b0f" + }, + "source": [ + "## Build Graph" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "67854e07-9293-4c3c-bf9a-bc9a605570ee", + "metadata": { + "id": "67854e07-9293-4c3c-bf9a-bc9a605570ee" + }, + "outputs": [], + "source": [ + "import pprint\n", + "\n", + "from langgraph.graph import END, StateGraph, START\n", + "\n", + "workflow = StateGraph(GraphState)\n", + "\n", + "# Define the nodes\n", + "workflow.add_node(\"web_search\", web_search) # web search\n", + "workflow.add_node(\"retrieve\", retrieve) # retrieve\n", + "workflow.add_node(\"grade_documents\", grade_documents) # grade documents\n", + "workflow.add_node(\"generate\", generate) # rag\n", + "workflow.add_node(\"llm_fallback\", llm_fallback) # llm\n", + "\n", + "# Build graph\n", + "workflow.add_conditional_edges(\n", + " START,\n", + " route_question,\n", + " {\n", + " \"web_search\": \"web_search\",\n", + " \"vectorstore\": \"retrieve\",\n", + " \"llm_fallback\": \"llm_fallback\",\n", + " },\n", + ")\n", + "workflow.add_edge(\"web_search\", \"generate\")\n", + "workflow.add_edge(\"retrieve\", \"grade_documents\")\n", + "workflow.add_conditional_edges(\n", + " \"grade_documents\",\n", + " decide_to_generate,\n", + " {\n", + " \"web_search\": \"web_search\",\n", + " \"generate\": \"generate\",\n", + " },\n", + ")\n", + "workflow.add_conditional_edges(\n", + " \"generate\",\n", + " grade_generation_v_documents_and_question,\n", + " {\n", + " \"not supported\": \"generate\", # Hallucinations: re-generate\n", + " \"not useful\": \"web_search\", # Fails to answer question: fall-back to web-search\n", + " \"useful\": END,\n", + " },\n", + ")\n", + "workflow.add_edge(\"llm_fallback\", END)\n", + "\n", + "# Compile\n", + "app = workflow.compile()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "29acc541-d726-4b75-84d1-a215845fe88a", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "29acc541-d726-4b75-84d1-a215845fe88a", + "outputId": "47caec8e-54e3-4f89-dfbb-94fc034666f7" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---ROUTE QUESTION---\n", + "---ROUTE QUESTION TO WEB SEARCH---\n", + "---WEB SEARCH---\n", + "\"Node 'web_search':\"\n", + "'\\n---\\n'\n", + "---GENERATE---\n", + "---CHECK HALLUCINATIONS---\n", + "---DECISION: GENERATION IS GROUNDED IN DOCUMENTS---\n", + "---GRADE GENERATION vs QUESTION---\n", + "---DECISION: GENERATION ADDRESSES QUESTION---\n", + "\"Node 'generate':\"\n", + "'\\n---\\n'\n", + "'The Bears are expected to draft Caleb Williams with their first pick.'\n" + ] + } + ], + "source": [ + "# Run\ninputs = {\n \"question\": \"What player are the Bears expected to draft first in the 2024 NFL draft?\"\n}\nfor output in app.stream(inputs):\n for key, value in output.items():\n # Node\n pprint.pprint(f\"Node '{key}':\")\n # Optional: print full state at each node\n pprint.pprint(\"\\n---\\n\")\n\n# Final generation\npprint.pprint(value[\"generation\"])" + ] + }, + { + "cell_type": "markdown", + "id": "11fddd00-58bf-4910-bf36-be9e5bfba778", + "metadata": { + "id": "11fddd00-58bf-4910-bf36-be9e5bfba778" + }, + "source": [ + "Trace:\n", + "\n", + "https://smith.langchain.com/public/623da7bb-84a7-4e53-a63e-7ccd77fb9be5/r" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "69a985dd-03c6-45af-a67b-b15746a2cb5f", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "69a985dd-03c6-45af-a67b-b15746a2cb5f", + "outputId": "e5f799cc-6f36-494f-c8b2-192de1edb7fc" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---ROUTE QUESTION---\n", + "---ROUTE QUESTION TO RAG---\n", + "---RETRIEVE---\n", + "\"Node 'retrieve':\"\n", + "'\\n---\\n'\n", + "---CHECK DOCUMENT RELEVANCE TO QUESTION---\n", + "---GRADE: DOCUMENT RELEVANT---\n", + "---GRADE: DOCUMENT RELEVANT---\n", + "---GRADE: DOCUMENT RELEVANT---\n", + "---GRADE: DOCUMENT RELEVANT---\n", + "---ASSESS GRADED DOCUMENTS---\n", + "---DECISION: GENERATE---\n", + "\"Node 'grade_documents':\"\n", + "'\\n---\\n'\n", + "---GENERATE---\n", + "---CHECK HALLUCINATIONS---\n", + "---DECISION: GENERATION IS GROUNDED IN DOCUMENTS---\n", + "---GRADE GENERATION vs QUESTION---\n", + "---DECISION: GENERATION ADDRESSES QUESTION---\n", + "\"Node 'generate':\"\n", + "'\\n---\\n'\n", + "'Sensory, short-term, and long-term memory.'\n" + ] + } + ], + "source": [ + "# Run\ninputs = {\"question\": \"What are the types of agent memory?\"}\nfor output in app.stream(inputs):\n for key, value in output.items():\n # Node\n pprint.pprint(f\"Node '{key}':\")\n # Optional: print full state at each node\n # pprint.pprint(value[\"keys\"], indent=2, width=80, depth=None)\n pprint.pprint(\"\\n---\\n\")\n\n# Final generation\npprint.pprint(value[\"generation\"])" + ] + }, + { + "cell_type": "markdown", + "id": "ebf41097-fc4c-4072-95b3-e7e07731ada1", + "metadata": { + "id": "ebf41097-fc4c-4072-95b3-e7e07731ada1" + }, + "source": [ + "Trace:\n", + "\n", + "https://smith.langchain.com/public/57f3973b-6879-4fbe-ae31-9ae524c3a697/r" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "qPwP_2PNiOjQ", + "metadata": { + "id": "qPwP_2PNiOjQ" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---ROUTE QUESTION---\n", + "---ROUTE QUESTION TO LLM---\n", + "---LLM Fallback---\n", + "\"Node 'llm_fallback':\"\n", + "'\\n---\\n'\n", + "(\"I don't have feelings as an AI assistant, but I'm here to help you with your \"\n", + " 'queries. How can I assist you today?')\n" + ] + } + ], + "source": [ + "# Run\ninputs = {\"question\": \"Hello, how are you today?\"}\nfor output in app.stream(inputs):\n for key, value in output.items():\n # Node\n pprint.pprint(f\"Node '{key}':\")\n # Optional: print full state at each node\n # pprint.pprint(value[\"keys\"], indent=2, width=80, depth=None)\n pprint.pprint(\"\\n---\\n\")\n\n# Final generation\npprint.pprint(value[\"generation\"])" + ] + }, + { + "cell_type": "markdown", + "id": "4107c8a4-6171-4c1b-840a-77a3d09f84fc", + "metadata": {}, + "source": [ + "Trace: \n", + "\n", + "https://smith.langchain.com/public/1f628ee4-8d2d-451e-aeb1-5d5e0ede2b4f/r" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ce3cda0a-c4bd-41ea-830b-d992f27fde15", + "metadata": {}, + "outputs": [], + "source": [ + "" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/rag/langgraph_adaptive_rag_local.ipynb b/examples/rag/langgraph_adaptive_rag_local.ipynb new file mode 100644 index 000000000..4a0435e38 --- /dev/null +++ b/examples/rag/langgraph_adaptive_rag_local.ipynb @@ -0,0 +1,838 @@ +{ + "cells": [ + { + "attachments": { + "3755396d-c4a8-45bd-87d4-00cb56339fe5.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "bb89d3f0-7ade-43a8-a527-4bec45971cf6", + "metadata": {}, + "source": [ + "# Adaptive RAG using local LLMs\n", + "\n", + "Adaptive RAG is a strategy for RAG that unites (1) [query analysis](https://blog.langchain.dev/query-construction/) with (2) [active / self-corrective RAG](https://blog.langchain.dev/agentic-rag-with-langgraph/).\n", + "\n", + "In the [paper](https://arxiv.org/abs/2403.14403), they report query analysis to route across:\n", + "\n", + "* No Retrieval\n", + "* Single-shot RAG\n", + "* Iterative RAG\n", + "\n", + "Let's build on this using LangGraph. \n", + "\n", + "In our implementation, we will route between:\n", + "\n", + "* Web search: for questions related to recent events\n", + "* Self-corrective RAG: for questions related to our index\n", + "\n", + "![Screenshot 2024-04-01 at 1.29.15 PM.png](attachment:3755396d-c4a8-45bd-87d4-00cb56339fe5.png)" + ] + }, + { + "cell_type": "markdown", + "id": "8cece98f-a3ed-417e-8b6a-1754e8f9c42a", + "metadata": {}, + "source": [ + "## Setup\n", + "\n", + "First, let's install our required packages and set our API keys" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "88debf5c-6972-415c-b8fb-f65eab203b7a", + "metadata": {}, + "outputs": [], + "source": [ + "%capture --no-stderr\n", + "%pip install -U langchain-nomic langchain_community tiktoken langchainhub chromadb langchain langgraph tavily-python nomic[local]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2369652a", + "metadata": {}, + "outputs": [], + "source": [ + "import getpass\n", + "import os\n", + "\n", + "\n", + "def _set_env(var: str):\n", + " if not os.environ.get(var):\n", + " os.environ[var] = getpass.getpass(f\"{var}: \")\n", + "\n", + "\n", + "_set_env(\"TAVILY_API_KEY\")\n", + "_set_env(\"NOMIC_API_KEY\")" + ] + }, + { + "cell_type": "markdown", + "id": "aea269f6", + "metadata": {}, + "source": [ + "
\n", + "

Set up LangSmith for LangGraph development

\n", + "

\n", + " Sign up for LangSmith to quickly spot issues and improve the performance of your LangGraph projects. LangSmith lets you use trace data to debug, test, and monitor your LLM apps built with LangGraph — read more about how to get started here. \n", + "

\n", + "
" + ] + }, + { + "cell_type": "markdown", + "id": "6a5d4a26-249b-4551-aa13-6c373429618e", + "metadata": {}, + "source": [ + "### LLMs\n", + "\n", + "#### Local Embeddings\n", + "\n", + "You can use `GPT4AllEmbeddings()` from Nomic, which can access use Nomic's recently released [v1](https://blog.nomic.ai/posts/nomic-embed-text-v1) and [v1.5](https://blog.nomic.ai/posts/nomic-embed-matryoshka) embeddings.\n", + "\n", + "Follow the documentation [here](https://docs.gpt4all.io/gpt4all_python_embedding.html#supported-embedding-models).\n", + "\n", + "#### Local LLM\n", + "\n", + "(1) Download [Ollama app](https://ollama.ai/).\n", + "\n", + "(2) Download a `Mistral` model from various Mistral versions [here](https://ollama.ai/library/mistral) and Mixtral versions [here](https://ollama.ai/library/mixtral) available. Also, try one of the [quantized command-R models](https://ollama.com/library/command-r).\n", + "\n", + "```\n", + "ollama pull mistral\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "af8379bd-7eae-4ba6-b632-12e89eab9920", + "metadata": {}, + "outputs": [], + "source": [ + "# Ollama model name\n", + "local_llm = \"mistral\"" + ] + }, + { + "cell_type": "markdown", + "id": "04718a0c-7a48-4243-97a2-940a0239cc12", + "metadata": {}, + "source": [ + "## Create Index" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "f9ff6b99-080d-4827-b2cb-f775543d76f5", + "metadata": {}, + "outputs": [], + "source": [ + "from langchain.text_splitter import RecursiveCharacterTextSplitter\n", + "from langchain_community.document_loaders import WebBaseLoader\n", + "from langchain_community.vectorstores import Chroma\n", + "from langchain_nomic.embeddings import NomicEmbeddings\n", + "\n", + "urls = [\n", + " \"https://lilianweng.github.io/posts/2023-06-23-agent/\",\n", + " \"https://lilianweng.github.io/posts/2023-03-15-prompt-engineering/\",\n", + " \"https://lilianweng.github.io/posts/2023-10-25-adv-attack-llm/\",\n", + "]\n", + "\n", + "docs = [WebBaseLoader(url).load() for url in urls]\n", + "docs_list = [item for sublist in docs for item in sublist]\n", + "\n", + "text_splitter = RecursiveCharacterTextSplitter.from_tiktoken_encoder(\n", + " chunk_size=250, chunk_overlap=0\n", + ")\n", + "doc_splits = text_splitter.split_documents(docs_list)\n", + "\n", + "# Add to vectorDB\n", + "vectorstore = Chroma.from_documents(\n", + " documents=doc_splits,\n", + " collection_name=\"rag-chroma\",\n", + " embedding=NomicEmbeddings(model=\"nomic-embed-text-v1.5\", inference_mode=\"local\"),\n", + ")\n", + "retriever = vectorstore.as_retriever()" + ] + }, + { + "cell_type": "markdown", + "id": "2f3eb922-27a1-4a72-a727-85fbf5b3daf1", + "metadata": {}, + "source": [ + "## LLMs\n", + "\n", + "Note: tested cmd-R on Mac M2 32GB and [latency is ~52 sec for RAG generation](https://smith.langchain.com/public/3998fe48-efc2-4d18-9069-972643d0982d/r)." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "7045e064-e666-4aea-9111-6e9d2007f27e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'datasource': 'vectorstore'}\n" + ] + } + ], + "source": [ + "### Router\n", + "\n", + "from langchain.prompts import PromptTemplate\n", + "from langchain_community.chat_models import ChatOllama\n", + "from langchain_core.output_parsers import JsonOutputParser\n", + "\n", + "# LLM\n", + "llm = ChatOllama(model=local_llm, format=\"json\", temperature=0)\n", + "\n", + "prompt = PromptTemplate(\n", + " template=\"\"\"You are an expert at routing a user question to a vectorstore or web search. \\n\n", + " Use the vectorstore for questions on LLM agents, prompt engineering, and adversarial attacks. \\n\n", + " You do not need to be stringent with the keywords in the question related to these topics. \\n\n", + " Otherwise, use web-search. Give a binary choice 'web_search' or 'vectorstore' based on the question. \\n\n", + " Return the a JSON with a single key 'datasource' and no premable or explanation. \\n\n", + " Question to route: {question}\"\"\",\n", + " input_variables=[\"question\"],\n", + ")\n", + "\n", + "question_router = prompt | llm | JsonOutputParser()\n", + "question = \"llm agent memory\"\n", + "docs = retriever.get_relevant_documents(question)\n", + "doc_txt = docs[1].page_content\n", + "print(question_router.invoke({\"question\": question}))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "813cdcef-8b75-4214-a2ed-b89077b3d287", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'score': 'yes'}\n" + ] + } + ], + "source": [ + "### Retrieval Grader\n", + "\n", + "from langchain.prompts import PromptTemplate\n", + "from langchain_community.chat_models import ChatOllama\n", + "from langchain_core.output_parsers import JsonOutputParser\n", + "\n", + "# LLM\n", + "llm = ChatOllama(model=local_llm, format=\"json\", temperature=0)\n", + "\n", + "prompt = PromptTemplate(\n", + " template=\"\"\"You are a grader assessing relevance of a retrieved document to a user question. \\n \n", + " Here is the retrieved document: \\n\\n {document} \\n\\n\n", + " Here is the user question: {question} \\n\n", + " If the document contains keywords related to the user question, grade it as relevant. \\n\n", + " It does not need to be a stringent test. The goal is to filter out erroneous retrievals. \\n\n", + " Give a binary score 'yes' or 'no' score to indicate whether the document is relevant to the question. \\n\n", + " Provide the binary score as a JSON with a single key 'score' and no premable or explanation.\"\"\",\n", + " input_variables=[\"question\", \"document\"],\n", + ")\n", + "\n", + "retrieval_grader = prompt | llm | JsonOutputParser()\n", + "question = \"agent memory\"\n", + "docs = retriever.get_relevant_documents(question)\n", + "doc_txt = docs[1].page_content\n", + "print(retrieval_grader.invoke({\"question\": question, \"document\": doc_txt}))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "aeb8b373-0289-4dec-bd4b-8b2701200301", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " In an LLM-powered autonomous agent system, the Large Language Model (LLM) functions as the agent's brain. The agent has key components including memory, planning, and reflection mechanisms. The memory component is a long-term memory module that records a comprehensive list of agents’ experience in natural language. It includes a memory stream, which is an external database for storing past experiences. The reflection mechanism synthesizes memories into higher-level inferences over time and guides the agent's future behavior.\n" + ] + } + ], + "source": [ + "### Generate\n", + "\n", + "from langchain import hub\n", + "from langchain_community.chat_models import ChatOllama\n", + "from langchain_core.output_parsers import StrOutputParser\n", + "\n", + "# Prompt\n", + "prompt = hub.pull(\"rlm/rag-prompt\")\n", + "\n", + "# LLM\n", + "llm = ChatOllama(model=local_llm, temperature=0)\n", + "\n", + "\n", + "# Post-processing\n", + "def format_docs(docs):\n", + " return \"\\n\\n\".join(doc.page_content for doc in docs)\n", + "\n", + "\n", + "# Chain\n", + "rag_chain = prompt | llm | StrOutputParser()\n", + "\n", + "# Run\n", + "question = \"agent memory\"\n", + "generation = rag_chain.invoke({\"context\": docs, \"question\": question})\n", + "print(generation)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "38345cff-e2d0-436e-aa09-599522a61eed", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'score': 'yes'}" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "### Hallucination Grader\n", + "\n", + "# LLM\n", + "llm = ChatOllama(model=local_llm, format=\"json\", temperature=0)\n", + "\n", + "# Prompt\n", + "prompt = PromptTemplate(\n", + " template=\"\"\"You are a grader assessing whether an answer is grounded in / supported by a set of facts. \\n \n", + " Here are the facts:\n", + " \\n ------- \\n\n", + " {documents} \n", + " \\n ------- \\n\n", + " Here is the answer: {generation}\n", + " Give a binary score 'yes' or 'no' score to indicate whether the answer is grounded in / supported by a set of facts. \\n\n", + " Provide the binary score as a JSON with a single key 'score' and no preamble or explanation.\"\"\",\n", + " input_variables=[\"generation\", \"documents\"],\n", + ")\n", + "\n", + "hallucination_grader = prompt | llm | JsonOutputParser()\n", + "hallucination_grader.invoke({\"documents\": docs, \"generation\": generation})" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "9771caa1-5542-47c3-8354-aeeafcf51964", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'score': 'yes'}" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "### Answer Grader\n", + "\n", + "# LLM\n", + "llm = ChatOllama(model=local_llm, format=\"json\", temperature=0)\n", + "\n", + "# Prompt\n", + "prompt = PromptTemplate(\n", + " template=\"\"\"You are a grader assessing whether an answer is useful to resolve a question. \\n \n", + " Here is the answer:\n", + " \\n ------- \\n\n", + " {generation} \n", + " \\n ------- \\n\n", + " Here is the question: {question}\n", + " Give a binary score 'yes' or 'no' to indicate whether the answer is useful to resolve a question. \\n\n", + " Provide the binary score as a JSON with a single key 'score' and no preamble or explanation.\"\"\",\n", + " input_variables=[\"generation\", \"question\"],\n", + ")\n", + "\n", + "answer_grader = prompt | llm | JsonOutputParser()\n", + "answer_grader.invoke({\"question\": question, \"generation\": generation})" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "830ba5f7-9c8d-4c01-83b1-e4d51d40d48f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "' What is agent memory and how can it be effectively utilized in vector database retrieval?'" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "### Question Re-writer\n", + "\n", + "# LLM\n", + "llm = ChatOllama(model=local_llm, temperature=0)\n", + "\n", + "# Prompt\n", + "re_write_prompt = PromptTemplate(\n", + " template=\"\"\"You a question re-writer that converts an input question to a better version that is optimized \\n \n", + " for vectorstore retrieval. Look at the initial and formulate an improved question. \\n\n", + " Here is the initial question: \\n\\n {question}. Improved question with no preamble: \\n \"\"\",\n", + " input_variables=[\"generation\", \"question\"],\n", + ")\n", + "\n", + "question_rewriter = re_write_prompt | llm | StrOutputParser()\n", + "question_rewriter.invoke({\"question\": question})" + ] + }, + { + "cell_type": "markdown", + "id": "686c9bb1-5069-45f9-8a7e-cba34fe07dd9", + "metadata": {}, + "source": [ + "## Web Search Tool" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "6c3c1c70-ff84-41e8-bf72-738ed52f2dde", + "metadata": {}, + "outputs": [], + "source": [ + "### Search\n", + "\n", + "from langchain_community.tools.tavily_search import TavilySearchResults\n", + "\n", + "web_search_tool = TavilySearchResults(k=3)" + ] + }, + { + "cell_type": "markdown", + "id": "630d1751-a20b-4858-b3fd-0312de4f3ad7", + "metadata": {}, + "source": [ + "# Graph \n", + "\n", + "Capture the flow in as a graph.\n", + "\n", + "## Graph state" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "6e09087e-b2a9-437a-abee-129e426df799", + "metadata": {}, + "outputs": [], + "source": [ + "from typing import List\n", + "\n", + "from typing_extensions import TypedDict\n", + "\n", + "\n", + "class GraphState(TypedDict):\n", + " \"\"\"\n", + " Represents the state of our graph.\n", + "\n", + " Attributes:\n", + " question: question\n", + " generation: LLM generation\n", + " documents: list of documents\n", + " \"\"\"\n", + "\n", + " question: str\n", + " generation: str\n", + " documents: List[str]" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "7c5fa507-77ae-426a-a65f-f518b9525bd0", + "metadata": {}, + "outputs": [], + "source": [ + "### Nodes\n", + "\n", + "from langchain.schema import Document\n", + "\n", + "\n", + "def retrieve(state):\n", + " \"\"\"\n", + " Retrieve documents\n", + "\n", + " Args:\n", + " state (dict): The current graph state\n", + "\n", + " Returns:\n", + " state (dict): New key added to state, documents, that contains retrieved documents\n", + " \"\"\"\n", + " print(\"---RETRIEVE---\")\n", + " question = state[\"question\"]\n", + "\n", + " # Retrieval\n", + " documents = retriever.get_relevant_documents(question)\n", + " return {\"documents\": documents, \"question\": question}\n", + "\n", + "\n", + "def generate(state):\n", + " \"\"\"\n", + " Generate answer\n", + "\n", + " Args:\n", + " state (dict): The current graph state\n", + "\n", + " Returns:\n", + " state (dict): New key added to state, generation, that contains LLM generation\n", + " \"\"\"\n", + " print(\"---GENERATE---\")\n", + " question = state[\"question\"]\n", + " documents = state[\"documents\"]\n", + "\n", + " # RAG generation\n", + " generation = rag_chain.invoke({\"context\": documents, \"question\": question})\n", + " return {\"documents\": documents, \"question\": question, \"generation\": generation}\n", + "\n", + "\n", + "def grade_documents(state):\n", + " \"\"\"\n", + " Determines whether the retrieved documents are relevant to the question.\n", + "\n", + " Args:\n", + " state (dict): The current graph state\n", + "\n", + " Returns:\n", + " state (dict): Updates documents key with only filtered relevant documents\n", + " \"\"\"\n", + "\n", + " print(\"---CHECK DOCUMENT RELEVANCE TO QUESTION---\")\n", + " question = state[\"question\"]\n", + " documents = state[\"documents\"]\n", + "\n", + " # Score each doc\n", + " filtered_docs = []\n", + " for d in documents:\n", + " score = retrieval_grader.invoke(\n", + " {\"question\": question, \"document\": d.page_content}\n", + " )\n", + " grade = score[\"score\"]\n", + " if grade == \"yes\":\n", + " print(\"---GRADE: DOCUMENT RELEVANT---\")\n", + " filtered_docs.append(d)\n", + " else:\n", + " print(\"---GRADE: DOCUMENT NOT RELEVANT---\")\n", + " continue\n", + " return {\"documents\": filtered_docs, \"question\": question}\n", + "\n", + "\n", + "def transform_query(state):\n", + " \"\"\"\n", + " Transform the query to produce a better question.\n", + "\n", + " Args:\n", + " state (dict): The current graph state\n", + "\n", + " Returns:\n", + " state (dict): Updates question key with a re-phrased question\n", + " \"\"\"\n", + "\n", + " print(\"---TRANSFORM QUERY---\")\n", + " question = state[\"question\"]\n", + " documents = state[\"documents\"]\n", + "\n", + " # Re-write question\n", + " better_question = question_rewriter.invoke({\"question\": question})\n", + " return {\"documents\": documents, \"question\": better_question}\n", + "\n", + "\n", + "def web_search(state):\n", + " \"\"\"\n", + " Web search based on the re-phrased question.\n", + "\n", + " Args:\n", + " state (dict): The current graph state\n", + "\n", + " Returns:\n", + " state (dict): Updates documents key with appended web results\n", + " \"\"\"\n", + "\n", + " print(\"---WEB SEARCH---\")\n", + " question = state[\"question\"]\n", + "\n", + " # Web search\n", + " docs = web_search_tool.invoke({\"query\": question})\n", + " web_results = \"\\n\".join([d[\"content\"] for d in docs])\n", + " web_results = Document(page_content=web_results)\n", + "\n", + " return {\"documents\": web_results, \"question\": question}\n", + "\n", + "\n", + "### Edges ###\n", + "\n", + "\n", + "def route_question(state):\n", + " \"\"\"\n", + " Route question to web search or RAG.\n", + "\n", + " Args:\n", + " state (dict): The current graph state\n", + "\n", + " Returns:\n", + " str: Next node to call\n", + " \"\"\"\n", + "\n", + " print(\"---ROUTE QUESTION---\")\n", + " question = state[\"question\"]\n", + " print(question)\n", + " source = question_router.invoke({\"question\": question})\n", + " print(source)\n", + " print(source[\"datasource\"])\n", + " if source[\"datasource\"] == \"web_search\":\n", + " print(\"---ROUTE QUESTION TO WEB SEARCH---\")\n", + " return \"web_search\"\n", + " elif source[\"datasource\"] == \"vectorstore\":\n", + " print(\"---ROUTE QUESTION TO RAG---\")\n", + " return \"vectorstore\"\n", + "\n", + "\n", + "def decide_to_generate(state):\n", + " \"\"\"\n", + " Determines whether to generate an answer, or re-generate a question.\n", + "\n", + " Args:\n", + " state (dict): The current graph state\n", + "\n", + " Returns:\n", + " str: Binary decision for next node to call\n", + " \"\"\"\n", + "\n", + " print(\"---ASSESS GRADED DOCUMENTS---\")\n", + " state[\"question\"]\n", + " filtered_documents = state[\"documents\"]\n", + "\n", + " if not filtered_documents:\n", + " # All documents have been filtered check_relevance\n", + " # We will re-generate a new query\n", + " print(\n", + " \"---DECISION: ALL DOCUMENTS ARE NOT RELEVANT TO QUESTION, TRANSFORM QUERY---\"\n", + " )\n", + " return \"transform_query\"\n", + " else:\n", + " # We have relevant documents, so generate answer\n", + " print(\"---DECISION: GENERATE---\")\n", + " return \"generate\"\n", + "\n", + "\n", + "def grade_generation_v_documents_and_question(state):\n", + " \"\"\"\n", + " Determines whether the generation is grounded in the document and answers question.\n", + "\n", + " Args:\n", + " state (dict): The current graph state\n", + "\n", + " Returns:\n", + " str: Decision for next node to call\n", + " \"\"\"\n", + "\n", + " print(\"---CHECK HALLUCINATIONS---\")\n", + " question = state[\"question\"]\n", + " documents = state[\"documents\"]\n", + " generation = state[\"generation\"]\n", + "\n", + " score = hallucination_grader.invoke(\n", + " {\"documents\": documents, \"generation\": generation}\n", + " )\n", + " grade = score[\"score\"]\n", + "\n", + " # Check hallucination\n", + " if grade == \"yes\":\n", + " print(\"---DECISION: GENERATION IS GROUNDED IN DOCUMENTS---\")\n", + " # Check question-answering\n", + " print(\"---GRADE GENERATION vs QUESTION---\")\n", + " score = answer_grader.invoke({\"question\": question, \"generation\": generation})\n", + " grade = score[\"score\"]\n", + " if grade == \"yes\":\n", + " print(\"---DECISION: GENERATION ADDRESSES QUESTION---\")\n", + " return \"useful\"\n", + " else:\n", + " print(\"---DECISION: GENERATION DOES NOT ADDRESS QUESTION---\")\n", + " return \"not useful\"\n", + " else:\n", + " pprint(\"---DECISION: GENERATION IS NOT GROUNDED IN DOCUMENTS, RE-TRY---\")\n", + " return \"not supported\"" + ] + }, + { + "cell_type": "markdown", + "id": "ed7d8eb6-31d7-4ab5-8a88-7081b64582bb", + "metadata": {}, + "source": [ + "## Build Graph" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "450eb313-ca75-4a43-b57e-7034bd3f40bf", + "metadata": {}, + "outputs": [], + "source": [ + "from langgraph.graph import END, StateGraph, START\n", + "\n", + "workflow = StateGraph(GraphState)\n", + "\n", + "# Define the nodes\n", + "workflow.add_node(\"web_search\", web_search) # web search\n", + "workflow.add_node(\"retrieve\", retrieve) # retrieve\n", + "workflow.add_node(\"grade_documents\", grade_documents) # grade documents\n", + "workflow.add_node(\"generate\", generate) # generate\n", + "workflow.add_node(\"transform_query\", transform_query) # transform_query\n", + "\n", + "# Build graph\n", + "workflow.add_conditional_edges(\n", + " START,\n", + " route_question,\n", + " {\n", + " \"web_search\": \"web_search\",\n", + " \"vectorstore\": \"retrieve\",\n", + " },\n", + ")\n", + "workflow.add_edge(\"web_search\", \"generate\")\n", + "workflow.add_edge(\"retrieve\", \"grade_documents\")\n", + "workflow.add_conditional_edges(\n", + " \"grade_documents\",\n", + " decide_to_generate,\n", + " {\n", + " \"transform_query\": \"transform_query\",\n", + " \"generate\": \"generate\",\n", + " },\n", + ")\n", + "workflow.add_edge(\"transform_query\", \"retrieve\")\n", + "workflow.add_conditional_edges(\n", + " \"generate\",\n", + " grade_generation_v_documents_and_question,\n", + " {\n", + " \"not supported\": \"generate\",\n", + " \"useful\": END,\n", + " \"not useful\": \"transform_query\",\n", + " },\n", + ")\n", + "\n", + "# Compile\n", + "app = workflow.compile()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "b095c1db-8bd1-4a34-937c-1a9b74ae74ff", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---ROUTE QUESTION---\n", + "What is the AlphaCodium paper about?\n", + "{'datasource': 'web_search'}\n", + "web_search\n", + "---ROUTE QUESTION TO WEB SEARCH---\n", + "---WEB SEARCH---\n", + "\"Node 'web_search':\"\n", + "'\\n---\\n'\n", + "---GENERATE---\n", + "---CHECK HALLUCINATIONS---\n", + "---DECISION: GENERATION IS GROUNDED IN DOCUMENTS---\n", + "---GRADE GENERATION vs QUESTION---\n", + "---DECISION: GENERATION ADDRESSES QUESTION---\n", + "\"Node 'generate':\"\n", + "'\\n---\\n'\n", + "(' The AlphaCodium paper introduces a new approach for code generation by '\n", + " 'Large Language Models (LLMs). It presents AlphaCodium, an iterative process '\n", + " 'that involves generating additional data to aid the flow, and testing it on '\n", + " 'the CodeContests dataset. The results show that AlphaCodium outperforms '\n", + " \"DeepMind's AlphaCode and AlphaCode2 without fine-tuning a model. The \"\n", + " 'approach includes a pre-processing phase for problem reasoning in natural '\n", + " 'language and an iterative code generation phase with runs and fixes against '\n", + " 'tests.')\n" + ] + } + ], + "source": [ + "from pprint import pprint\n", + "\n", + "# Run\n", + "inputs = {\"question\": \"What is the AlphaCodium paper about?\"}\n", + "for output in app.stream(inputs):\n", + " for key, value in output.items():\n", + " # Node\n", + " pprint(f\"Node '{key}':\")\n", + " # Optional: print full state at each node\n", + " # pprint.pprint(value[\"keys\"], indent=2, width=80, depth=None)\n", + " pprint(\"\\n---\\n\")\n", + "\n", + "# Final generation\n", + "pprint(value[\"generation\"])" + ] + }, + { + "cell_type": "markdown", + "id": "644c7293-9cb5-4236-ba08-1e63b0309cb7", + "metadata": {}, + "source": [ + "Trace: \n", + "\n", + "https://smith.langchain.com/public/81813813-be53-403c-9877-afcd5786ca2e/r" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/rag/langgraph_agentic_rag.ipynb b/examples/rag/langgraph_agentic_rag.ipynb new file mode 100644 index 000000000..27e957b6c --- /dev/null +++ b/examples/rag/langgraph_agentic_rag.ipynb @@ -0,0 +1,539 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "425fb020-e864-40ce-a31f-8da40c73d14b", + "metadata": {}, + "source": [ + "# Agentic RAG\n", + "\n", + "[Retrieval Agents](https://python.langchain.com/v0.2/docs/tutorials/qa_chat_history/#agents) are useful when we want to make decisions about whether to retrieve from an index.\n", + "\n", + "To implement a retrieval agent, we simple need to give an LLM access to a retriever tool.\n", + "\n", + "We can incorporate this into [LangGraph](https://langchain-ai.github.io/langgraph/).\n", + "\n", + "## Setup\n", + "\n", + "First, let's download the required packages and set our API keys:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "969fb438", + "metadata": {}, + "outputs": [], + "source": [ + "%%capture --no-stderr\n", + "%pip install -U --quiet langchain-community tiktoken langchain-openai langchainhub chromadb langchain langgraph langchain-text-splitters" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "e4958a8c", + "metadata": {}, + "outputs": [], + "source": [ + "import getpass\n", + "import os\n", + "\n", + "\n", + "def _set_env(key: str):\n", + " if key not in os.environ:\n", + " os.environ[key] = getpass.getpass(f\"{key}:\")\n", + "\n", + "\n", + "_set_env(\"OPENAI_API_KEY\")" + ] + }, + { + "cell_type": "markdown", + "id": "3d07e8d4", + "metadata": {}, + "source": [ + "
\n", + "

Set up LangSmith for LangGraph development

\n", + "

\n", + " Sign up for LangSmith to quickly spot issues and improve the performance of your LangGraph projects. LangSmith lets you use trace data to debug, test, and monitor your LLM apps built with LangGraph — read more about how to get started here. \n", + "

\n", + "
" + ] + }, + { + "cell_type": "markdown", + "id": "c74e4532", + "metadata": {}, + "source": [ + "## Retriever\n", + "\n", + "First, we index 3 blog posts." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e50c9efe-4abe-42fa-b35a-05eeeede9ec6", + "metadata": {}, + "outputs": [], + "source": [ + "from langchain_community.document_loaders import WebBaseLoader\n", + "from langchain_community.vectorstores import Chroma\n", + "from langchain_openai import OpenAIEmbeddings\n", + "from langchain_text_splitters import RecursiveCharacterTextSplitter\n", + "\n", + "urls = [\n", + " \"https://lilianweng.github.io/posts/2023-06-23-agent/\",\n", + " \"https://lilianweng.github.io/posts/2023-03-15-prompt-engineering/\",\n", + " \"https://lilianweng.github.io/posts/2023-10-25-adv-attack-llm/\",\n", + "]\n", + "\n", + "docs = [WebBaseLoader(url).load() for url in urls]\n", + "docs_list = [item for sublist in docs for item in sublist]\n", + "\n", + "text_splitter = RecursiveCharacterTextSplitter.from_tiktoken_encoder(\n", + " chunk_size=100, chunk_overlap=50\n", + ")\n", + "doc_splits = text_splitter.split_documents(docs_list)\n", + "\n", + "# Add to vectorDB\n", + "vectorstore = Chroma.from_documents(\n", + " documents=doc_splits,\n", + " collection_name=\"rag-chroma\",\n", + " embedding=OpenAIEmbeddings(),\n", + ")\n", + "retriever = vectorstore.as_retriever()" + ] + }, + { + "cell_type": "markdown", + "id": "225d2277-45b2-4ae8-a7d6-62b07fb4a002", + "metadata": {}, + "source": [ + "Then we create a retriever tool." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "0b97bdd8-d7e3-444d-ac96-5ef4725f9048", + "metadata": {}, + "outputs": [], + "source": [ + "from langchain.tools.retriever import create_retriever_tool\n", + "\n", + "retriever_tool = create_retriever_tool(\n", + " retriever,\n", + " \"retrieve_blog_posts\",\n", + " \"Search and return information about Lilian Weng blog posts on LLM agents, prompt engineering, and adversarial attacks on LLMs.\",\n", + ")\n", + "\n", + "tools = [retriever_tool]" + ] + }, + { + "cell_type": "markdown", + "id": "fe6e8f78-1ef7-42ad-b2bf-835ed5850553", + "metadata": {}, + "source": [ + "## Agent State\n", + " \n", + "We will define a graph.\n", + "\n", + "A `state` object that it passes around to each node.\n", + "\n", + "Our state will be a list of `messages`.\n", + "\n", + "Each node in our graph will append to it." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "0e378706-47d5-425a-8ba0-57b9acffbd0c", + "metadata": {}, + "outputs": [], + "source": [ + "from typing import Annotated, Sequence, TypedDict\n", + "\n", + "from langchain_core.messages import BaseMessage\n", + "\n", + "from langgraph.graph.message import add_messages\n", + "\n", + "\n", + "class AgentState(TypedDict):\n", + " # The add_messages function defines how an update should be processed\n", + " # Default is to replace. add_messages says \"append\"\n", + " messages: Annotated[Sequence[BaseMessage], add_messages]" + ] + }, + { + "attachments": { + "7ad1a116-28d7-473f-8cff-5f2efd0bf118.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "dc949d42-8a34-4231-bff0-b8198975e2ce", + "metadata": {}, + "source": [ + "## Nodes and Edges\n", + "\n", + "We can lay out an agentic RAG graph like this:\n", + "\n", + "* The state is a set of messages\n", + "* Each node will update (append to) state\n", + "* Conditional edges decide which node to visit next\n", + "\n", + "![Screenshot 2024-02-14 at 3.43.58 PM.png](attachment:7ad1a116-28d7-473f-8cff-5f2efd0bf118.png)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "278d1d83-dda6-4de4-bf8b-be9965c227fa", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "********************Prompt[rlm/rag-prompt]********************\n", + "================================\u001B[1m Human Message \u001B[0m=================================\n", + "\n", + "You are an assistant for question-answering tasks. Use the following pieces of retrieved context to answer the question. If you don't know the answer, just say that you don't know. Use three sentences maximum and keep the answer concise.\n", + "Question: \u001B[33;1m\u001B[1;3m{question}\u001B[0m \n", + "Context: \u001B[33;1m\u001B[1;3m{context}\u001B[0m \n", + "Answer:\n" + ] + } + ], + "source": [ + "from typing import Annotated, Literal, Sequence, TypedDict\n", + "\n", + "from langchain import hub\n", + "from langchain_core.messages import BaseMessage, HumanMessage\n", + "from langchain_core.output_parsers import StrOutputParser\n", + "from langchain_core.prompts import PromptTemplate\n", + "from langchain_core.pydantic_v1 import BaseModel, Field\n", + "from langchain_openai import ChatOpenAI\n", + "\n", + "from langgraph.prebuilt import tools_condition\n", + "\n", + "### Edges\n", + "\n", + "\n", + "def grade_documents(state) -> Literal[\"generate\", \"rewrite\"]:\n", + " \"\"\"\n", + " Determines whether the retrieved documents are relevant to the question.\n", + "\n", + " Args:\n", + " state (messages): The current state\n", + "\n", + " Returns:\n", + " str: A decision for whether the documents are relevant or not\n", + " \"\"\"\n", + "\n", + " print(\"---CHECK RELEVANCE---\")\n", + "\n", + " # Data model\n", + " class grade(BaseModel):\n", + " \"\"\"Binary score for relevance check.\"\"\"\n", + "\n", + " binary_score: str = Field(description=\"Relevance score 'yes' or 'no'\")\n", + "\n", + " # LLM\n", + " model = ChatOpenAI(temperature=0, model=\"gpt-4o\", streaming=True)\n", + "\n", + " # LLM with tool and validation\n", + " llm_with_tool = model.with_structured_output(grade)\n", + "\n", + " # Prompt\n", + " prompt = PromptTemplate(\n", + " template=\"\"\"You are a grader assessing relevance of a retrieved document to a user question. \\n \n", + " Here is the retrieved document: \\n\\n {context} \\n\\n\n", + " Here is the user question: {question} \\n\n", + " If the document contains keyword(s) or semantic meaning related to the user question, grade it as relevant. \\n\n", + " Give a binary score 'yes' or 'no' score to indicate whether the document is relevant to the question.\"\"\",\n", + " input_variables=[\"context\", \"question\"],\n", + " )\n", + "\n", + " # Chain\n", + " chain = prompt | llm_with_tool\n", + "\n", + " messages = state[\"messages\"]\n", + " last_message = messages[-1]\n", + "\n", + " question = messages[0].content\n", + " docs = last_message.content\n", + "\n", + " scored_result = chain.invoke({\"question\": question, \"context\": docs})\n", + "\n", + " score = scored_result.binary_score\n", + "\n", + " if score == \"yes\":\n", + " print(\"---DECISION: DOCS RELEVANT---\")\n", + " return \"generate\"\n", + "\n", + " else:\n", + " print(\"---DECISION: DOCS NOT RELEVANT---\")\n", + " print(score)\n", + " return \"rewrite\"\n", + "\n", + "\n", + "### Nodes\n", + "\n", + "\n", + "def agent(state):\n", + " \"\"\"\n", + " Invokes the agent model to generate a response based on the current state. Given\n", + " the question, it will decide to retrieve using the retriever tool, or simply end.\n", + "\n", + " Args:\n", + " state (messages): The current state\n", + "\n", + " Returns:\n", + " dict: The updated state with the agent response appended to messages\n", + " \"\"\"\n", + " print(\"---CALL AGENT---\")\n", + " messages = state[\"messages\"]\n", + " model = ChatOpenAI(temperature=0, streaming=True, model=\"gpt-4-turbo\")\n", + " model = model.bind_tools(tools)\n", + " response = model.invoke(messages)\n", + " # We return a list, because this will get added to the existing list\n", + " return {\"messages\": [response]}\n", + "\n", + "\n", + "def rewrite(state):\n", + " \"\"\"\n", + " Transform the query to produce a better question.\n", + "\n", + " Args:\n", + " state (messages): The current state\n", + "\n", + " Returns:\n", + " dict: The updated state with re-phrased question\n", + " \"\"\"\n", + "\n", + " print(\"---TRANSFORM QUERY---\")\n", + " messages = state[\"messages\"]\n", + " question = messages[0].content\n", + "\n", + " msg = [\n", + " HumanMessage(\n", + " content=f\"\"\" \\n \n", + " Look at the input and try to reason about the underlying semantic intent / meaning. \\n \n", + " Here is the initial question:\n", + " \\n ------- \\n\n", + " {question} \n", + " \\n ------- \\n\n", + " Formulate an improved question: \"\"\",\n", + " )\n", + " ]\n", + "\n", + " # Grader\n", + " model = ChatOpenAI(temperature=0, model=\"gpt-4-0125-preview\", streaming=True)\n", + " response = model.invoke(msg)\n", + " return {\"messages\": [response]}\n", + "\n", + "\n", + "def generate(state):\n", + " \"\"\"\n", + " Generate answer\n", + "\n", + " Args:\n", + " state (messages): The current state\n", + "\n", + " Returns:\n", + " dict: The updated state with re-phrased question\n", + " \"\"\"\n", + " print(\"---GENERATE---\")\n", + " messages = state[\"messages\"]\n", + " question = messages[0].content\n", + " last_message = messages[-1]\n", + "\n", + " docs = last_message.content\n", + "\n", + " # Prompt\n", + " prompt = hub.pull(\"rlm/rag-prompt\")\n", + "\n", + " # LLM\n", + " llm = ChatOpenAI(model_name=\"gpt-3.5-turbo\", temperature=0, streaming=True)\n", + "\n", + " # Post-processing\n", + " def format_docs(docs):\n", + " return \"\\n\\n\".join(doc.page_content for doc in docs)\n", + "\n", + " # Chain\n", + " rag_chain = prompt | llm | StrOutputParser()\n", + "\n", + " # Run\n", + " response = rag_chain.invoke({\"context\": docs, \"question\": question})\n", + " return {\"messages\": [response]}\n", + "\n", + "\n", + "print(\"*\" * 20 + \"Prompt[rlm/rag-prompt]\" + \"*\" * 20)\n", + "prompt = hub.pull(\"rlm/rag-prompt\").pretty_print() # Show what the prompt looks like" + ] + }, + { + "cell_type": "markdown", + "id": "955882ef-7467-48db-ae51-de441f2fc3a7", + "metadata": {}, + "source": [ + "## Graph\n", + "\n", + "* Start with an agent, `call_model`\n", + "* Agent make a decision to call a function\n", + "* If so, then `action` to call tool (retriever)\n", + "* Then call agent with the tool output added to messages (`state`)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "8718a37f-83c2-4f16-9850-e61e0f49c3d4", + "metadata": {}, + "outputs": [], + "source": [ + "from langgraph.graph import END, StateGraph, START\n", + "from langgraph.prebuilt import ToolNode\n", + "\n", + "# Define a new graph\n", + "workflow = StateGraph(AgentState)\n", + "\n", + "# Define the nodes we will cycle between\n", + "workflow.add_node(\"agent\", agent) # agent\n", + "retrieve = ToolNode([retriever_tool])\n", + "workflow.add_node(\"retrieve\", retrieve) # retrieval\n", + "workflow.add_node(\"rewrite\", rewrite) # Re-writing the question\n", + "workflow.add_node(\n", + " \"generate\", generate\n", + ") # Generating a response after we know the documents are relevant\n", + "# Call agent node to decide to retrieve or not\n", + "workflow.add_edge(START, \"agent\")\n", + "\n", + "# Decide whether to retrieve\n", + "workflow.add_conditional_edges(\n", + " \"agent\",\n", + " # Assess agent decision\n", + " tools_condition,\n", + " {\n", + " # Translate the condition outputs to nodes in our graph\n", + " \"tools\": \"retrieve\",\n", + " END: END,\n", + " },\n", + ")\n", + "\n", + "# Edges taken after the `action` node is called.\n", + "workflow.add_conditional_edges(\n", + " \"retrieve\",\n", + " # Assess agent decision\n", + " grade_documents,\n", + ")\n", + "workflow.add_edge(\"generate\", END)\n", + "workflow.add_edge(\"rewrite\", \"agent\")\n", + "\n", + "# Compile\n", + "graph = workflow.compile()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "7b5a1d35", + "metadata": {}, + "outputs": [ + { + "data": { + "image/jpeg": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from IPython.display import Image, display\n", + "\n", + "try:\n", + " display(Image(graph.get_graph(xray=True).draw_mermaid_png()))\n", + "except Exception:\n", + " # This requires some extra dependencies and is optional\n", + " pass" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "7649f05a-cb67-490d-b24a-74d41895139a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---CALL AGENT---\n", + "\"Output from node 'agent':\"\n", + "'---'\n", + "{ 'messages': [ AIMessage(content='', additional_kwargs={'tool_calls': [{'index': 0, 'id': 'call_z36oPZN8l1UC6raxrebqc1bH', 'function': {'arguments': '{\"query\":\"types of agent memory\"}', 'name': 'retrieve_blog_posts'}, 'type': 'function'}]}, response_metadata={'finish_reason': 'tool_calls'}, id='run-2bad2518-8187-4d8f-8e23-2b9501becb6f-0', tool_calls=[{'name': 'retrieve_blog_posts', 'args': {'query': 'types of agent memory'}, 'id': 'call_z36oPZN8l1UC6raxrebqc1bH'}])]}\n", + "'\\n---\\n'\n", + "---CHECK RELEVANCE---\n", + "---DECISION: DOCS RELEVANT---\n", + "\"Output from node 'retrieve':\"\n", + "'---'\n", + "{ 'messages': [ ToolMessage(content='Table of Contents\\n\\n\\n\\nAgent System Overview\\n\\nComponent One: Planning\\n\\nTask Decomposition\\n\\nSelf-Reflection\\n\\n\\nComponent Two: Memory\\n\\nTypes of Memory\\n\\nMaximum Inner Product Search (MIPS)\\n\\n\\nComponent Three: Tool Use\\n\\nCase Studies\\n\\nScientific Discovery Agent\\n\\nGenerative Agents Simulation\\n\\nProof-of-Concept Examples\\n\\n\\nChallenges\\n\\nCitation\\n\\nReferences\\n\\nPlanning\\n\\nSubgoal and decomposition: The agent breaks down large tasks into smaller, manageable subgoals, enabling efficient handling of complex tasks.\\nReflection and refinement: The agent can do self-criticism and self-reflection over past actions, learn from mistakes and refine them for future steps, thereby improving the quality of final results.\\n\\n\\nMemory\\n\\nMemory\\n\\nShort-term memory: I would consider all the in-context learning (See Prompt Engineering) as utilizing short-term memory of the model to learn.\\nLong-term memory: This provides the agent with the capability to retain and recall (infinite) information over extended periods, often by leveraging an external vector store and fast retrieval.\\n\\n\\nTool use\\n\\nThe design of generative agents combines LLM with memory, planning and reflection mechanisms to enable agents to behave conditioned on past experience, as well as to interact with other agents.', name='retrieve_blog_posts', id='d815f283-868c-4660-a1c6-5f6e5373ca06', tool_call_id='call_z36oPZN8l1UC6raxrebqc1bH')]}\n", + "'\\n---\\n'\n", + "---GENERATE---\n", + "\"Output from node 'generate':\"\n", + "'---'\n", + "{ 'messages': [ 'Lilian Weng discusses short-term and long-term memory in '\n", + " 'agent systems. Short-term memory is used for in-context '\n", + " 'learning, while long-term memory allows agents to retain and '\n", + " 'recall information over extended periods.']}\n", + "'\\n---\\n'\n" + ] + } + ], + "source": [ + "import pprint\n", + "\n", + "inputs = {\n", + " \"messages\": [\n", + " (\"user\", \"What does Lilian Weng say about the types of agent memory?\"),\n", + " ]\n", + "}\n", + "for output in graph.stream(inputs):\n", + " for key, value in output.items():\n", + " pprint.pprint(f\"Output from node '{key}':\")\n", + " pprint.pprint(\"---\")\n", + " pprint.pprint(value, indent=2, width=80, depth=None)\n", + " pprint.pprint(\"\\n---\\n\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/rag/langgraph_crag.ipynb b/examples/rag/langgraph_crag.ipynb new file mode 100644 index 000000000..009ad25ff --- /dev/null +++ b/examples/rag/langgraph_crag.ipynb @@ -0,0 +1,701 @@ +{ + "cells": [ + { + "attachments": { + "683fae34-980f-43f0-a9c2-9894bebd9157.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "8889a307-fa3f-4d38-9127-d41e4686ae47", + "metadata": {}, + "source": [ + "# Corrective RAG (CRAG)\n", + "\n", + "Corrective-RAG (CRAG) is a strategy for RAG that incorporates self-reflection / self-grading on retrieved documents. \n", + "\n", + "In the paper [here](https://arxiv.org/pdf/2401.15884.pdf), a few steps are taken:\n", + "\n", + "* If at least one document exceeds the threshold for relevance, then it proceeds to generation\n", + "* Before generation, it performs knowledge refinement\n", + "* This partitions the document into \"knowledge strips\"\n", + "* It grades each strip, and filters our irrelevant ones\n", + "* If all documents fall below the relevance threshold or if the grader is unsure, then the framework seeks an additional datasource\n", + "* It will use web search to supplement retrieval\n", + " \n", + "We will implement some of these ideas from scratch using [LangGraph](https://langchain-ai.github.io/langgraph/):\n", + "\n", + "* Let's skip the knowledge refinement phase as a first pass. This can be added back as a node, if desired. \n", + "* If *any* documents are irrelevant, let's opt to supplement retrieval with web search. \n", + "* We'll use [Tavily Search](https://python.langchain.com/v0.2/docs/integrations/tools/tavily_search/) for web search.\n", + "* Let's use query re-writing to optimize the query for web search.\n", + "\n", + "![Screenshot 2024-04-01 at 9.28.30 AM.png](attachment:683fae34-980f-43f0-a9c2-9894bebd9157.png)" + ] + }, + { + "cell_type": "markdown", + "id": "4931ac25-99f9-4f04-b3d1-4683f7853667", + "metadata": {}, + "source": [ + "## Setup\n", + "\n", + "First, let's download our required packages and set our API keys" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "568c84d6-9df6-4b7b-b50d-476c0a64a04b", + "metadata": {}, + "outputs": [], + "source": [ + "! pip install langchain_community tiktoken langchain-openai langchainhub chromadb langchain langgraph tavily-python" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "74710419-158d-4270-931c-de83db7b580d", + "metadata": {}, + "outputs": [], + "source": [ + "import getpass\n", + "import os\n", + "\n", + "\n", + "def _set_env(key: str):\n", + " if key not in os.environ:\n", + " os.environ[key] = getpass.getpass(f\"{key}:\")\n", + "\n", + "\n", + "_set_env(\"OPENAI_API_KEY\")\n", + "_set_env(\"TAVILY_API_KEY\")" + ] + }, + { + "cell_type": "markdown", + "id": "3adde047", + "metadata": {}, + "source": [ + "
\n", + "

Set up LangSmith for LangGraph development

\n", + "

\n", + " Sign up for LangSmith to quickly spot issues and improve the performance of your LangGraph projects. LangSmith lets you use trace data to debug, test, and monitor your LLM apps built with LangGraph — read more about how to get started here. \n", + "

\n", + "
" + ] + }, + { + "cell_type": "markdown", + "id": "a21f32d2-92ce-4995-b309-99347bafe3be", + "metadata": {}, + "source": [ + "## Create Index\n", + " \n", + "Let's index 3 blog posts." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "3a566a30-cf0e-4330-ad4d-9bf994bdfa86", + "metadata": {}, + "outputs": [], + "source": [ + "from langchain.text_splitter import RecursiveCharacterTextSplitter\n", + "from langchain_community.document_loaders import WebBaseLoader\n", + "from langchain_community.vectorstores import Chroma\n", + "from langchain_openai import OpenAIEmbeddings\n", + "\n", + "urls = [\n", + " \"https://lilianweng.github.io/posts/2023-06-23-agent/\",\n", + " \"https://lilianweng.github.io/posts/2023-03-15-prompt-engineering/\",\n", + " \"https://lilianweng.github.io/posts/2023-10-25-adv-attack-llm/\",\n", + "]\n", + "\n", + "docs = [WebBaseLoader(url).load() for url in urls]\n", + "docs_list = [item for sublist in docs for item in sublist]\n", + "\n", + "text_splitter = RecursiveCharacterTextSplitter.from_tiktoken_encoder(\n", + " chunk_size=250, chunk_overlap=0\n", + ")\n", + "doc_splits = text_splitter.split_documents(docs_list)\n", + "\n", + "# Add to vectorDB\n", + "vectorstore = Chroma.from_documents(\n", + " documents=doc_splits,\n", + " collection_name=\"rag-chroma\",\n", + " embedding=OpenAIEmbeddings(),\n", + ")\n", + "retriever = vectorstore.as_retriever()" + ] + }, + { + "cell_type": "markdown", + "id": "6fca2db8-8d68-42b0-981d-4be5ccdbe293", + "metadata": {}, + "source": [ + "## LLMs" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "7ece414c-2df5-4ffd-aa82-550a65775261", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "binary_score='yes'\n" + ] + } + ], + "source": [ + "### Retrieval Grader\n", + "\n", + "from langchain_core.prompts import ChatPromptTemplate\n", + "from langchain_core.pydantic_v1 import BaseModel, Field\n", + "from langchain_openai import ChatOpenAI\n", + "\n", + "\n", + "# Data model\n", + "class GradeDocuments(BaseModel):\n", + " \"\"\"Binary score for relevance check on retrieved documents.\"\"\"\n", + "\n", + " binary_score: str = Field(\n", + " description=\"Documents are relevant to the question, 'yes' or 'no'\"\n", + " )\n", + "\n", + "\n", + "# LLM with function call\n", + "llm = ChatOpenAI(model=\"gpt-4o-mini\", temperature=0)\n", + "structured_llm_grader = llm.with_structured_output(GradeDocuments)\n", + "\n", + "# Prompt\n", + "system = \"\"\"You are a grader assessing relevance of a retrieved document to a user question. \\n \n", + " If the document contains keyword(s) or semantic meaning related to the question, grade it as relevant. \\n\n", + " Give a binary score 'yes' or 'no' score to indicate whether the document is relevant to the question.\"\"\"\n", + "grade_prompt = ChatPromptTemplate.from_messages(\n", + " [\n", + " (\"system\", system),\n", + " (\"human\", \"Retrieved document: \\n\\n {document} \\n\\n User question: {question}\"),\n", + " ]\n", + ")\n", + "\n", + "retrieval_grader = grade_prompt | structured_llm_grader\n", + "question = \"agent memory\"\n", + "docs = retriever.get_relevant_documents(question)\n", + "doc_txt = docs[1].page_content\n", + "print(retrieval_grader.invoke({\"question\": question, \"document\": doc_txt}))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a207c85f-e414-46b7-8999-4c0ead1493da", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The design of generative agents combines LLM with memory, planning, and reflection mechanisms to enable agents to behave conditioned on past experience. Memory stream is a long-term memory module that records a comprehensive list of agents' experience in natural language. Short-term memory is utilized for in-context learning, while long-term memory allows agents to retain and recall information over extended periods.\n" + ] + } + ], + "source": [ + "### Generate\n", + "\n", + "from langchain import hub\n", + "from langchain_core.output_parsers import StrOutputParser\n", + "\n", + "# Prompt\n", + "prompt = hub.pull(\"rlm/rag-prompt\")\n", + "\n", + "# LLM\n", + "llm = ChatOpenAI(model_name=\"gpt-3.5-turbo\", temperature=0)\n", + "\n", + "\n", + "# Post-processing\n", + "def format_docs(docs):\n", + " return \"\\n\\n\".join(doc.page_content for doc in docs)\n", + "\n", + "\n", + "# Chain\n", + "rag_chain = prompt | llm | StrOutputParser()\n", + "\n", + "# Run\n", + "generation = rag_chain.invoke({\"context\": docs, \"question\": question})\n", + "print(generation)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "30d0a69b-9087-4f85-af26-cab55b567872", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'What is the role of memory in artificial intelligence agents?'" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "### Question Re-writer\n", + "\n", + "# LLM\n", + "llm = ChatOpenAI(model=\"gpt-3.5-turbo-0125\", temperature=0)\n", + "\n", + "# Prompt\n", + "system = \"\"\"You a question re-writer that converts an input question to a better version that is optimized \\n \n", + " for web search. Look at the input and try to reason about the underlying semantic intent / meaning.\"\"\"\n", + "re_write_prompt = ChatPromptTemplate.from_messages(\n", + " [\n", + " (\"system\", system),\n", + " (\n", + " \"human\",\n", + " \"Here is the initial question: \\n\\n {question} \\n Formulate an improved question.\",\n", + " ),\n", + " ]\n", + ")\n", + "\n", + "question_rewriter = re_write_prompt | llm | StrOutputParser()\n", + "question_rewriter.invoke({\"question\": question})" + ] + }, + { + "cell_type": "markdown", + "id": "e4538467-4a15-4733-b93c-2b79d4d6bf25", + "metadata": {}, + "source": [ + "## Web Search Tool" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "46d51b53-54a9-4e0a-9f14-e39998f5b340", + "metadata": {}, + "outputs": [], + "source": [ + "### Search\n", + "\n", + "from langchain_community.tools.tavily_search import TavilySearchResults\n", + "\n", + "web_search_tool = TavilySearchResults(k=3)" + ] + }, + { + "cell_type": "markdown", + "id": "87194a1b-535a-4593-ab95-5736fae176d1", + "metadata": {}, + "source": [ + "## Create Graph \n", + "\n", + "Now let's create our graph that will use CRAG\n", + "\n", + "### Define Graph State" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "94b3945f-ef0f-458d-a443-f763903550b0", + "metadata": {}, + "outputs": [], + "source": [ + "from typing import List\n", + "\n", + "from typing_extensions import TypedDict\n", + "\n", + "\n", + "class GraphState(TypedDict):\n", + " \"\"\"\n", + " Represents the state of our graph.\n", + "\n", + " Attributes:\n", + " question: question\n", + " generation: LLM generation\n", + " web_search: whether to add search\n", + " documents: list of documents\n", + " \"\"\"\n", + "\n", + " question: str\n", + " generation: str\n", + " web_search: str\n", + " documents: List[str]" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "efd639c5-82e2-45e6-a94a-6a4039646ef5", + "metadata": {}, + "outputs": [], + "source": [ + "from langchain.schema import Document\n", + "\n", + "\n", + "def retrieve(state):\n", + " \"\"\"\n", + " Retrieve documents\n", + "\n", + " Args:\n", + " state (dict): The current graph state\n", + "\n", + " Returns:\n", + " state (dict): New key added to state, documents, that contains retrieved documents\n", + " \"\"\"\n", + " print(\"---RETRIEVE---\")\n", + " question = state[\"question\"]\n", + "\n", + " # Retrieval\n", + " documents = retriever.get_relevant_documents(question)\n", + " return {\"documents\": documents, \"question\": question}\n", + "\n", + "\n", + "def generate(state):\n", + " \"\"\"\n", + " Generate answer\n", + "\n", + " Args:\n", + " state (dict): The current graph state\n", + "\n", + " Returns:\n", + " state (dict): New key added to state, generation, that contains LLM generation\n", + " \"\"\"\n", + " print(\"---GENERATE---\")\n", + " question = state[\"question\"]\n", + " documents = state[\"documents\"]\n", + "\n", + " # RAG generation\n", + " generation = rag_chain.invoke({\"context\": documents, \"question\": question})\n", + " return {\"documents\": documents, \"question\": question, \"generation\": generation}\n", + "\n", + "\n", + "def grade_documents(state):\n", + " \"\"\"\n", + " Determines whether the retrieved documents are relevant to the question.\n", + "\n", + " Args:\n", + " state (dict): The current graph state\n", + "\n", + " Returns:\n", + " state (dict): Updates documents key with only filtered relevant documents\n", + " \"\"\"\n", + "\n", + " print(\"---CHECK DOCUMENT RELEVANCE TO QUESTION---\")\n", + " question = state[\"question\"]\n", + " documents = state[\"documents\"]\n", + "\n", + " # Score each doc\n", + " filtered_docs = []\n", + " web_search = \"No\"\n", + " for d in documents:\n", + " score = retrieval_grader.invoke(\n", + " {\"question\": question, \"document\": d.page_content}\n", + " )\n", + " grade = score.binary_score\n", + " if grade == \"yes\":\n", + " print(\"---GRADE: DOCUMENT RELEVANT---\")\n", + " filtered_docs.append(d)\n", + " else:\n", + " print(\"---GRADE: DOCUMENT NOT RELEVANT---\")\n", + " web_search = \"Yes\"\n", + " continue\n", + " return {\"documents\": filtered_docs, \"question\": question, \"web_search\": web_search}\n", + "\n", + "\n", + "def transform_query(state):\n", + " \"\"\"\n", + " Transform the query to produce a better question.\n", + "\n", + " Args:\n", + " state (dict): The current graph state\n", + "\n", + " Returns:\n", + " state (dict): Updates question key with a re-phrased question\n", + " \"\"\"\n", + "\n", + " print(\"---TRANSFORM QUERY---\")\n", + " question = state[\"question\"]\n", + " documents = state[\"documents\"]\n", + "\n", + " # Re-write question\n", + " better_question = question_rewriter.invoke({\"question\": question})\n", + " return {\"documents\": documents, \"question\": better_question}\n", + "\n", + "\n", + "def web_search(state):\n", + " \"\"\"\n", + " Web search based on the re-phrased question.\n", + "\n", + " Args:\n", + " state (dict): The current graph state\n", + "\n", + " Returns:\n", + " state (dict): Updates documents key with appended web results\n", + " \"\"\"\n", + "\n", + " print(\"---WEB SEARCH---\")\n", + " question = state[\"question\"]\n", + " documents = state[\"documents\"]\n", + "\n", + " # Web search\n", + " docs = web_search_tool.invoke({\"query\": question})\n", + " web_results = \"\\n\".join([d[\"content\"] for d in docs])\n", + " web_results = Document(page_content=web_results)\n", + " documents.append(web_results)\n", + "\n", + " return {\"documents\": documents, \"question\": question}\n", + "\n", + "\n", + "### Edges\n", + "\n", + "\n", + "def decide_to_generate(state):\n", + " \"\"\"\n", + " Determines whether to generate an answer, or re-generate a question.\n", + "\n", + " Args:\n", + " state (dict): The current graph state\n", + "\n", + " Returns:\n", + " str: Binary decision for next node to call\n", + " \"\"\"\n", + "\n", + " print(\"---ASSESS GRADED DOCUMENTS---\")\n", + " state[\"question\"]\n", + " web_search = state[\"web_search\"]\n", + " state[\"documents\"]\n", + "\n", + " if web_search == \"Yes\":\n", + " # All documents have been filtered check_relevance\n", + " # We will re-generate a new query\n", + " print(\n", + " \"---DECISION: ALL DOCUMENTS ARE NOT RELEVANT TO QUESTION, TRANSFORM QUERY---\"\n", + " )\n", + " return \"transform_query\"\n", + " else:\n", + " # We have relevant documents, so generate answer\n", + " print(\"---DECISION: GENERATE---\")\n", + " return \"generate\"" + ] + }, + { + "cell_type": "markdown", + "id": "fa076e90-7132-4fcf-8507-db5990314c4f", + "metadata": {}, + "source": [ + "### Compile Graph\n", + "\n", + "The just follows the flow we outlined in the figure above." + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "dedae17a-98c6-474d-90a7-9234b7c8cea0", + "metadata": {}, + "outputs": [], + "source": [ + "from langgraph.graph import END, StateGraph, START\n", + "\n", + "workflow = StateGraph(GraphState)\n", + "\n", + "# Define the nodes\n", + "workflow.add_node(\"retrieve\", retrieve) # retrieve\n", + "workflow.add_node(\"grade_documents\", grade_documents) # grade documents\n", + "workflow.add_node(\"generate\", generate) # generate\n", + "workflow.add_node(\"transform_query\", transform_query) # transform_query\n", + "workflow.add_node(\"web_search_node\", web_search) # web search\n", + "\n", + "# Build graph\n", + "workflow.add_edge(START, \"retrieve\")\n", + "workflow.add_edge(\"retrieve\", \"grade_documents\")\n", + "workflow.add_conditional_edges(\n", + " \"grade_documents\",\n", + " decide_to_generate,\n", + " {\n", + " \"transform_query\": \"transform_query\",\n", + " \"generate\": \"generate\",\n", + " },\n", + ")\n", + "workflow.add_edge(\"transform_query\", \"web_search_node\")\n", + "workflow.add_edge(\"web_search_node\", \"generate\")\n", + "workflow.add_edge(\"generate\", END)\n", + "\n", + "# Compile\n", + "app = workflow.compile()" + ] + }, + { + "cell_type": "markdown", + "id": "27ba16a8", + "metadata": {}, + "source": [ + "## Use the graph" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "f5b7c2fe-1fc7-4b76-bf93-ba701a40aa6b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---RETRIEVE---\n", + "\"Node 'retrieve':\"\n", + "'\\n---\\n'\n", + "---CHECK DOCUMENT RELEVANCE TO QUESTION---\n", + "---GRADE: DOCUMENT NOT RELEVANT---\n", + "---GRADE: DOCUMENT NOT RELEVANT---\n", + "---GRADE: DOCUMENT RELEVANT---\n", + "---GRADE: DOCUMENT RELEVANT---\n", + "\"Node 'grade_documents':\"\n", + "'\\n---\\n'\n", + "---ASSESS GRADED DOCUMENTS---\n", + "---DECISION: ALL DOCUMENTS ARE NOT RELEVANT TO QUESTION, TRANSFORM QUERY---\n", + "---TRANSFORM QUERY---\n", + "\"Node 'transform_query':\"\n", + "'\\n---\\n'\n", + "---WEB SEARCH---\n", + "\"Node 'web_search_node':\"\n", + "'\\n---\\n'\n", + "---GENERATE---\n", + "\"Node 'generate':\"\n", + "'\\n---\\n'\n", + "\"Node '__end__':\"\n", + "'\\n---\\n'\n", + "('Agents possess short-term memory, which is utilized for in-context learning, '\n", + " 'and long-term memory, allowing them to retain and recall vast amounts of '\n", + " 'information over extended periods. Some experts also classify working memory '\n", + " 'as a distinct type, although it can be considered a part of short-term '\n", + " 'memory in many cases.')\n" + ] + } + ], + "source": [ + "from pprint import pprint\n", + "\n", + "# Run\n", + "inputs = {\"question\": \"What are the types of agent memory?\"}\n", + "for output in app.stream(inputs):\n", + " for key, value in output.items():\n", + " # Node\n", + " pprint(f\"Node '{key}':\")\n", + " # Optional: print full state at each node\n", + " # pprint.pprint(value[\"keys\"], indent=2, width=80, depth=None)\n", + " pprint(\"\\n---\\n\")\n", + "\n", + "# Final generation\n", + "pprint(value[\"generation\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "41ea1108-f385-4774-962d-db157922e231", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---RETRIEVE---\n", + "\"Node 'retrieve':\"\n", + "'\\n---\\n'\n", + "---CHECK DOCUMENT RELEVANCE TO QUESTION---\n", + "---GRADE: DOCUMENT NOT RELEVANT---\n", + "---GRADE: DOCUMENT NOT RELEVANT---\n", + "---GRADE: DOCUMENT NOT RELEVANT---\n", + "---GRADE: DOCUMENT RELEVANT---\n", + "\"Node 'grade_documents':\"\n", + "'\\n---\\n'\n", + "---ASSESS GRADED DOCUMENTS---\n", + "---DECISION: ALL DOCUMENTS ARE NOT RELEVANT TO QUESTION, TRANSFORM QUERY---\n", + "---TRANSFORM QUERY---\n", + "\"Node 'transform_query':\"\n", + "'\\n---\\n'\n", + "---WEB SEARCH---\n", + "\"Node 'web_search_node':\"\n", + "'\\n---\\n'\n", + "---GENERATE---\n", + "\"Node 'generate':\"\n", + "'\\n---\\n'\n", + "\"Node '__end__':\"\n", + "'\\n---\\n'\n", + "('The AlphaCodium paper functions by proposing a code-oriented iterative flow '\n", + " 'that involves repeatedly running and fixing generated code against '\n", + " 'input-output tests. Its key mechanisms include generating additional data '\n", + " 'like problem reflection and test reasoning to aid the iterative process, as '\n", + " 'well as enriching the code generation process. AlphaCodium aims to improve '\n", + " 'the performance of Large Language Models on code problems by following a '\n", + " 'test-based, multi-stage approach.')\n" + ] + } + ], + "source": [ + "from pprint import pprint\n", + "\n", + "# Run\n", + "inputs = {\"question\": \"How does the AlphaCodium paper work?\"}\n", + "for output in app.stream(inputs):\n", + " for key, value in output.items():\n", + " # Node\n", + " pprint(f\"Node '{key}':\")\n", + " # Optional: print full state at each node\n", + " # pprint.pprint(value[\"keys\"], indent=2, width=80, depth=None)\n", + " pprint(\"\\n---\\n\")\n", + "\n", + "# Final generation\n", + "pprint(value[\"generation\"])" + ] + }, + { + "cell_type": "markdown", + "id": "a7e44593-1959-4abf-8405-5e23aa9398f5", + "metadata": {}, + "source": [ + "LangSmith Traces - \n", + " \n", + "* https://smith.langchain.com/public/f6b1716c-e842-4282-9112-1026b93e246b/r\n", + "\n", + "* https://smith.langchain.com/public/497c8ed9-d9e2-429e-8ada-e64de3ec26c9/r" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/rag/langgraph_crag_local.ipynb b/examples/rag/langgraph_crag_local.ipynb new file mode 100644 index 000000000..c454127f2 --- /dev/null +++ b/examples/rag/langgraph_crag_local.ipynb @@ -0,0 +1,853 @@ +{ + "cells": [ + { + "attachments": { + "b77a7d3b-b28a-4dcf-9f1a-861f2f2c5f6c.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "92ddc4f4-f7bf-4e0e-b5a5-5abd8a008b21", + "metadata": {}, + "source": [ + "# Corrective RAG (CRAG) using local LLMs\n", + "\n", + "[Corrective-RAG (CRAG)](https://arxiv.org/abs/2401.15884) is a strategy for RAG that incorporates self-reflection / self-grading on retrieved documents. \n", + "\n", + "The paper follows this general flow:\n", + "\n", + "* If at least one document exceeds the threshold for `relevance`, then it proceeds to generation\n", + "* If all documents fall below the `relevance` threshold or if the grader is unsure, then it uses web search to supplement retrieval\n", + "* Before generation, it performs knowledge refinement of the search or retrieved documents\n", + "* This partitions the document into `knowledge strips`\n", + "* It grades each strip, and filters out irrelevant ones\n", + "\n", + "We will implement some of these ideas from scratch using [LangGraph](https://langchain-ai.github.io/langgraph/):\n", + "\n", + "* If *any* documents are irrelevant, we'll supplement retrieval with web search. \n", + "* We'll skip the knowledge refinement, but this can be added back as a node if desired. \n", + "* We'll use [Tavily Search](https://python.langchain.com/v0.2/docs/integrations/tools/tavily_search/) for web search.\n", + "\n", + "![Screenshot 2024-06-24 at 3.03.16 PM.png](attachment:b77a7d3b-b28a-4dcf-9f1a-861f2f2c5f6c.png)" + ] + }, + { + "cell_type": "markdown", + "id": "6ba4302f-09d9-4d2a-a18d-a6fd23704850", + "metadata": {}, + "source": [ + "## Setup\n", + "\n", + "We'll use [Ollama](https://ollama.ai/) to access a local LLM:\n", + "\n", + "* Download [Ollama app](https://ollama.ai/).\n", + "* Pull your model of choice, e.g.: `ollama pull llama3`\n", + "\n", + "We'll use [Tavily](https://python.langchain.com/v0.2/docs/integrations/tools/tavily_search/) for web search.\n", + "\n", + "We'll use a vectorstore with [Nomic local embeddings](https://blog.nomic.ai/posts/nomic-embed-text-v1) or, optionally, OpenAI embeddings.\n", + "\n", + "\n", + "Let's install our required packages and set our API keys:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4a660963-bd3d-4c87-b2e4-b6e432055211", + "metadata": {}, + "outputs": [], + "source": [ + "%%capture --no-stderr\n", + "%pip install -U langchain_community tiktoken langchainhub scikit-learn langchain langgraph tavily-python nomic[local] langchain-nomic langchain_openai" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "68316ba0-854b-41e1-9af5-1f9e965946e3", + "metadata": {}, + "outputs": [], + "source": [ + "import getpass\n", + "import os\n", + "\n", + "\n", + "def _set_env(key: str):\n", + " if key not in os.environ:\n", + " os.environ[key] = getpass.getpass(f\"{key}:\")\n", + "\n", + "\n", + "_set_env(\"OPENAI_API_KEY\")\n", + "_set_env(\"TAVILY_API_KEY\")" + ] + }, + { + "cell_type": "markdown", + "id": "98f863ea", + "metadata": {}, + "source": [ + "
\n", + "

Set up LangSmith for LangGraph development

\n", + "

\n", + " Sign up for LangSmith to quickly spot issues and improve the performance of your LangGraph projects. LangSmith lets you use trace data to debug, test, and monitor your LLM apps built with LangGraph — read more about how to get started here. \n", + "

\n", + "
" + ] + }, + { + "cell_type": "markdown", + "id": "c059c3a3-7f01-4d46-8289-fde4c1b4155f", + "metadata": {}, + "source": [ + "### LLM\n", + "\n", + "You can select from [Ollama LLMs](https://ollama.com/library)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "2f4db331-c4d0-4c7c-a9a5-0bebc8a89c6c", + "metadata": {}, + "outputs": [], + "source": [ + "local_llm = \"llama3\"\n", + "model_tested = \"llama3-8b\"\n", + "metadata = f\"CRAG, {model_tested}\"" + ] + }, + { + "cell_type": "markdown", + "id": "6e2b6eed-3b3f-44b5-a34a-4ade1e94caf0", + "metadata": {}, + "source": [ + "## Create Index\n", + "\n", + "Let's index 3 blog posts." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "bb8b789b-475b-4e1b-9c66-03504c837830", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "USER_AGENT environment variable not set, consider setting it to identify your requests.\n" + ] + } + ], + "source": [ + "from langchain.text_splitter import RecursiveCharacterTextSplitter\n", + "from langchain_community.document_loaders import WebBaseLoader\n", + "from langchain_community.vectorstores import SKLearnVectorStore\n", + "from langchain_nomic.embeddings import NomicEmbeddings # local\n", + "from langchain_openai import OpenAIEmbeddings # api\n", + "\n", + "# List of URLs to load documents from\n", + "urls = [\n", + " \"https://lilianweng.github.io/posts/2023-06-23-agent/\",\n", + " \"https://lilianweng.github.io/posts/2023-03-15-prompt-engineering/\",\n", + " \"https://lilianweng.github.io/posts/2023-10-25-adv-attack-llm/\",\n", + "]\n", + "\n", + "# Load documents from the URLs\n", + "docs = [WebBaseLoader(url).load() for url in urls]\n", + "docs_list = [item for sublist in docs for item in sublist]\n", + "\n", + "# Initialize a text splitter with specified chunk size and overlap\n", + "text_splitter = RecursiveCharacterTextSplitter.from_tiktoken_encoder(\n", + " chunk_size=250, chunk_overlap=0\n", + ")\n", + "\n", + "# Split the documents into chunks\n", + "doc_splits = text_splitter.split_documents(docs_list)\n", + "\n", + "# Embedding\n", + "\"\"\"\n", + "embedding=NomicEmbeddings(\n", + " model=\"nomic-embed-text-v1.5\",\n", + " inference_mode=\"local\",\n", + ")\n", + "\"\"\"\n", + "embedding = OpenAIEmbeddings()\n", + "\n", + "# Add the document chunks to the \"vector store\"\n", + "vectorstore = SKLearnVectorStore.from_documents(\n", + " documents=doc_splits,\n", + " embedding=embedding,\n", + ")\n", + "retriever = vectorstore.as_retriever(k=4)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "fe7fd10a-f64a-48de-a116-6d5890def1af", + "metadata": {}, + "source": [ + "## Define Tools" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "0e75c029-6c10-47c7-871c-1f4932b25309", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'score': '1'}\n" + ] + } + ], + "source": [ + "### Retrieval Grader\n", + "\n", + "from langchain.prompts import PromptTemplate\n", + "from langchain_community.chat_models import ChatOllama\n", + "from langchain_core.output_parsers import JsonOutputParser\n", + "from langchain_mistralai.chat_models import ChatMistralAI\n", + "\n", + "# LLM\n", + "llm = ChatOllama(model=local_llm, format=\"json\", temperature=0)\n", + "\n", + "# Prompt\n", + "prompt = PromptTemplate(\n", + " template=\"\"\"You are a teacher grading a quiz. You will be given: \n", + " 1/ a QUESTION\n", + " 2/ A FACT provided by the student\n", + " \n", + " You are grading RELEVANCE RECALL:\n", + " A score of 1 means that ANY of the statements in the FACT are relevant to the QUESTION. \n", + " A score of 0 means that NONE of the statements in the FACT are relevant to the QUESTION. \n", + " 1 is the highest (best) score. 0 is the lowest score you can give. \n", + " \n", + " Explain your reasoning in a step-by-step manner. Ensure your reasoning and conclusion are correct. \n", + " \n", + " Avoid simply stating the correct answer at the outset.\n", + " \n", + " Question: {question} \\n\n", + " Fact: \\n\\n {documents} \\n\\n\n", + " \n", + " Give a binary score 'yes' or 'no' score to indicate whether the document is relevant to the question. \\n\n", + " Provide the binary score as a JSON with a single key 'score' and no premable or explanation.\n", + " \"\"\",\n", + " input_variables=[\"question\", \"documents\"],\n", + ")\n", + "\n", + "retrieval_grader = prompt | llm | JsonOutputParser()\n", + "question = \"agent memory\"\n", + "docs = retriever.invoke(question)\n", + "doc_txt = docs[1].page_content\n", + "print(retrieval_grader.invoke({\"question\": question, \"documents\": doc_txt}))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "dad03302-bd93-43fc-949e-af51a3298cfa", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The document mentions \"memory stream\" which is a long-term memory module that records a comprehensive list of agents' experience in natural language. It also discusses short-term memory and long-term memory, with the latter providing the agent with the capability to retain and recall information over extended periods. Additionally, it mentions planning and reflection mechanisms that enable agents to behave conditioned on past experience.\n" + ] + } + ], + "source": [ + "### Generate\n", + "\n", + "from langchain_core.output_parsers import StrOutputParser\n", + "\n", + "# Prompt\n", + "prompt = PromptTemplate(\n", + " template=\"\"\"You are an assistant for question-answering tasks. \n", + " \n", + " Use the following documents to answer the question. \n", + " \n", + " If you don't know the answer, just say that you don't know. \n", + " \n", + " Use three sentences maximum and keep the answer concise:\n", + " Question: {question} \n", + " Documents: {documents} \n", + " Answer: \n", + " \"\"\",\n", + " input_variables=[\"question\", \"documents\"],\n", + ")\n", + "\n", + "# LLM\n", + "llm = ChatOllama(model=local_llm, temperature=0)\n", + "\n", + "# Chain\n", + "rag_chain = prompt | llm | StrOutputParser()\n", + "\n", + "# Run\n", + "generation = rag_chain.invoke({\"documents\": docs, \"question\": question})\n", + "print(generation)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "b36a2f36-bc5f-408d-a5e8-3fa203c233f6", + "metadata": {}, + "outputs": [], + "source": [ + "### Search\n", + "\n", + "from langchain_community.tools.tavily_search import TavilySearchResults\n", + "\n", + "web_search_tool = TavilySearchResults(k=3)" + ] + }, + { + "cell_type": "markdown", + "id": "a3421cf0-9067-43fe-8681-0d3189d15dd3", + "metadata": {}, + "source": [ + "## Create the Graph \n", + "\n", + "Here we'll explicitly define the majority of the control flow, only using an LLM to define a single branch point following grading." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "10028794-2fbc-43f9-aa4c-7fe3abd69c1e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/jpeg": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from typing import List\n", + "from typing_extensions import TypedDict\n", + "from IPython.display import Image, display\n", + "from langchain.schema import Document\n", + "from langgraph.graph import START, END, StateGraph\n", + "\n", + "\n", + "class GraphState(TypedDict):\n", + " \"\"\"\n", + " Represents the state of our graph.\n", + "\n", + " Attributes:\n", + " question: question\n", + " generation: LLM generation\n", + " search: whether to add search\n", + " documents: list of documents\n", + " \"\"\"\n", + "\n", + " question: str\n", + " generation: str\n", + " search: str\n", + " documents: List[str]\n", + " steps: List[str]\n", + "\n", + "\n", + "def retrieve(state):\n", + " \"\"\"\n", + " Retrieve documents\n", + "\n", + " Args:\n", + " state (dict): The current graph state\n", + "\n", + " Returns:\n", + " state (dict): New key added to state, documents, that contains retrieved documents\n", + " \"\"\"\n", + " question = state[\"question\"]\n", + " documents = retriever.invoke(question)\n", + " steps = state[\"steps\"]\n", + " steps.append(\"retrieve_documents\")\n", + " return {\"documents\": documents, \"question\": question, \"steps\": steps}\n", + "\n", + "\n", + "def generate(state):\n", + " \"\"\"\n", + " Generate answer\n", + "\n", + " Args:\n", + " state (dict): The current graph state\n", + "\n", + " Returns:\n", + " state (dict): New key added to state, generation, that contains LLM generation\n", + " \"\"\"\n", + "\n", + " question = state[\"question\"]\n", + " documents = state[\"documents\"]\n", + " generation = rag_chain.invoke({\"documents\": documents, \"question\": question})\n", + " steps = state[\"steps\"]\n", + " steps.append(\"generate_answer\")\n", + " return {\n", + " \"documents\": documents,\n", + " \"question\": question,\n", + " \"generation\": generation,\n", + " \"steps\": steps,\n", + " }\n", + "\n", + "\n", + "def grade_documents(state):\n", + " \"\"\"\n", + " Determines whether the retrieved documents are relevant to the question.\n", + "\n", + " Args:\n", + " state (dict): The current graph state\n", + "\n", + " Returns:\n", + " state (dict): Updates documents key with only filtered relevant documents\n", + " \"\"\"\n", + "\n", + " question = state[\"question\"]\n", + " documents = state[\"documents\"]\n", + " steps = state[\"steps\"]\n", + " steps.append(\"grade_document_retrieval\")\n", + " filtered_docs = []\n", + " search = \"No\"\n", + " for d in documents:\n", + " score = retrieval_grader.invoke(\n", + " {\"question\": question, \"documents\": d.page_content}\n", + " )\n", + " grade = score[\"score\"]\n", + " if grade == \"yes\":\n", + " filtered_docs.append(d)\n", + " else:\n", + " search = \"Yes\"\n", + " continue\n", + " return {\n", + " \"documents\": filtered_docs,\n", + " \"question\": question,\n", + " \"search\": search,\n", + " \"steps\": steps,\n", + " }\n", + "\n", + "\n", + "def web_search(state):\n", + " \"\"\"\n", + " Web search based on the re-phrased question.\n", + "\n", + " Args:\n", + " state (dict): The current graph state\n", + "\n", + " Returns:\n", + " state (dict): Updates documents key with appended web results\n", + " \"\"\"\n", + "\n", + " question = state[\"question\"]\n", + " documents = state.get(\"documents\", [])\n", + " steps = state[\"steps\"]\n", + " steps.append(\"web_search\")\n", + " web_results = web_search_tool.invoke({\"query\": question})\n", + " documents.extend(\n", + " [\n", + " Document(page_content=d[\"content\"], metadata={\"url\": d[\"url\"]})\n", + " for d in web_results\n", + " ]\n", + " )\n", + " return {\"documents\": documents, \"question\": question, \"steps\": steps}\n", + "\n", + "\n", + "def decide_to_generate(state):\n", + " \"\"\"\n", + " Determines whether to generate an answer, or re-generate a question.\n", + "\n", + " Args:\n", + " state (dict): The current graph state\n", + "\n", + " Returns:\n", + " str: Binary decision for next node to call\n", + " \"\"\"\n", + " search = state[\"search\"]\n", + " if search == \"Yes\":\n", + " return \"search\"\n", + " else:\n", + " return \"generate\"\n", + "\n", + "\n", + "# Graph\n", + "workflow = StateGraph(GraphState)\n", + "\n", + "# Define the nodes\n", + "workflow.add_node(\"retrieve\", retrieve) # retrieve\n", + "workflow.add_node(\"grade_documents\", grade_documents) # grade documents\n", + "workflow.add_node(\"generate\", generate) # generate\n", + "workflow.add_node(\"web_search\", web_search) # web search\n", + "\n", + "# Build graph\n", + "workflow.add_edge(START, \"retrieve\")\n", + "workflow.add_edge(\"retrieve\", \"grade_documents\")\n", + "workflow.add_conditional_edges(\n", + " \"grade_documents\",\n", + " decide_to_generate,\n", + " {\n", + " \"search\": \"web_search\",\n", + " \"generate\": \"generate\",\n", + " },\n", + ")\n", + "workflow.add_edge(\"web_search\", \"generate\")\n", + "workflow.add_edge(\"generate\", END)\n", + "\n", + "custom_graph = workflow.compile()\n", + "\n", + "display(Image(custom_graph.get_graph(xray=True).draw_mermaid_png()))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "447d1333-082d-479a-a6fa-0ac0df78bb9d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'response': 'According to the documents, there are two types of agent memory:\\n\\n* Short-term memory (STM): This is a data structure that holds information temporarily and allows the agent to process it when needed.\\n* Long-term memory (LTM): This provides the agent with the capability to retain and recall information over extended periods.\\n\\nThese types of memories allow the agent to learn, reason, and make decisions.',\n", + " 'steps': ['retrieve_documents',\n", + " 'grade_document_retrieval',\n", + " 'web_search',\n", + " 'generate_answer']}" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import uuid\n", + "\n", + "\n", + "def predict_custom_agent_local_answer(example: dict):\n", + " config = {\"configurable\": {\"thread_id\": str(uuid.uuid4())}}\n", + " state_dict = custom_graph.invoke(\n", + " {\"question\": example[\"input\"], \"steps\": []}, config\n", + " )\n", + " return {\"response\": state_dict[\"generation\"], \"steps\": state_dict[\"steps\"]}\n", + "\n", + "\n", + "example = {\"input\": \"What are the types of agent memory?\"}\n", + "response = predict_custom_agent_local_answer(example)\n", + "response" + ] + }, + { + "cell_type": "markdown", + "id": "91325c88-ec77-4c79-8a77-cb2e2842bcd4", + "metadata": {}, + "source": [ + "Trace: \n", + "\n", + "https://smith.langchain.com/public/88e7579e-2571-4cf6-98d2-1f9ce3359967/r" + ] + }, + { + "cell_type": "markdown", + "id": "1b80d5da-f698-40d2-a2fb-4eac89e35350", + "metadata": {}, + "source": [ + "## Evaluation\n", + "\n", + "Now we've defined two different agent architectures that do roughly the same thing!\n", + "\n", + "We can evaluate them. See our [conceptual guide](https://docs.smith.langchain.com/concepts/evaluation#agents) for context on agent evaluation.\n", + "\n", + "### Response\n", + "\n", + "First, we can assess how well [our agent performs on a set of question-answer pairs](https://docs.smith.langchain.com/tutorials/Developers/agents#response-evaluation).\n", + "\n", + "We'll create a dataset and save it in LangSmith." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "b83706ac-724b-46b1-9f08-66e6c4fac742", + "metadata": {}, + "outputs": [], + "source": [ + "from langsmith import Client\n", + "\n", + "client = Client()\n", + "\n", + "# Create a dataset\n", + "examples = [\n", + " (\n", + " \"How does the ReAct agent use self-reflection? \",\n", + " \"ReAct integrates reasoning and acting, performing actions - such tools like Wikipedia search API - and then observing / reasoning about the tool outputs.\",\n", + " ),\n", + " (\n", + " \"What are the types of biases that can arise with few-shot prompting?\",\n", + " \"The biases that can arise with few-shot prompting include (1) Majority label bias, (2) Recency bias, and (3) Common token bias.\",\n", + " ),\n", + " (\n", + " \"What are five types of adversarial attacks?\",\n", + " \"Five types of adversarial attacks are (1) Token manipulation, (2) Gradient based attack, (3) Jailbreak prompting, (4) Human red-teaming, (5) Model red-teaming.\",\n", + " ),\n", + " (\n", + " \"Who did the Chicago Bears draft first in the 2024 NFL draft”?\",\n", + " \"The Chicago Bears drafted Caleb Williams first in the 2024 NFL draft.\",\n", + " ),\n", + " (\"Who won the 2024 NBA finals?\", \"The Boston Celtics on the 2024 NBA finals\"),\n", + "]\n", + "\n", + "# Save it\n", + "dataset_name = \"Corrective RAG Agent Testing\"\n", + "if not client.has_dataset(dataset_name=dataset_name):\n", + " dataset = client.create_dataset(dataset_name=dataset_name)\n", + " inputs, outputs = zip(\n", + " *[({\"input\": text}, {\"output\": label}) for text, label in examples]\n", + " )\n", + " client.create_examples(inputs=inputs, outputs=outputs, dataset_id=dataset.id)" + ] + }, + { + "cell_type": "markdown", + "id": "a23f6bc0-2d03-488c-8f4b-747c93876788", + "metadata": {}, + "source": [ + "Now, we'll use an `LLM as a grader` to compare both agent responses to our ground truth reference answer.\n", + "\n", + "[Here](https://smith.langchain.com/hub/rlm/rag-answer-vs-reference) is the default prompt that we can use.\n", + "\n", + "We'll use `gpt-4o` as our LLM grader.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "0a63776c-f9cd-46ce-b8cf-95c066dc5b06", + "metadata": {}, + "outputs": [], + "source": [ + "from langchain import hub\n", + "from langchain_openai import ChatOpenAI\n", + "\n", + "# Grade prompt\n", + "grade_prompt_answer_accuracy = hub.pull(\"langchain-ai/rag-answer-vs-reference\")\n", + "\n", + "\n", + "def answer_evaluator(run, example) -> dict:\n", + " \"\"\"\n", + " A simple evaluator for RAG answer accuracy\n", + " \"\"\"\n", + "\n", + " # Get the question, the ground truth reference answer, RAG chain answer prediction\n", + " input_question = example.inputs[\"input\"]\n", + " reference = example.outputs[\"output\"]\n", + " prediction = run.outputs[\"response\"]\n", + "\n", + " # Define an LLM grader\n", + " llm = ChatOpenAI(model=\"gpt-4o\", temperature=0)\n", + " answer_grader = grade_prompt_answer_accuracy | llm\n", + "\n", + " # Run evaluator\n", + " score = answer_grader.invoke(\n", + " {\n", + " \"question\": input_question,\n", + " \"correct_answer\": reference,\n", + " \"student_answer\": prediction,\n", + " }\n", + " )\n", + " score = score[\"Score\"]\n", + " return {\"key\": \"answer_v_reference_score\", \"score\": score}" + ] + }, + { + "cell_type": "markdown", + "id": "960f1a01-7f8c-429f-83d0-052cea47b32b", + "metadata": {}, + "source": [ + "### Trajectory\n", + "\n", + "Second, [we can assess the list of tool calls](https://docs.smith.langchain.com/tutorials/Developers/agents#trajectory) that each agent makes relative to expected trajectories.\n", + "\n", + "This evaluates the specific reasoning traces taken by our agents!" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "deb28175-27a1-4afc-9747-2983e87fc881", + "metadata": {}, + "outputs": [], + "source": [ + "from langsmith.schemas import Example, Run\n", + "\n", + "# Reasoning traces that we expect the agents to take\n", + "expected_trajectory_1 = [\n", + " \"retrieve_documents\",\n", + " \"grade_document_retrieval\",\n", + " \"web_search\",\n", + " \"generate_answer\",\n", + "]\n", + "expected_trajectory_2 = [\n", + " \"retrieve_documents\",\n", + " \"grade_document_retrieval\",\n", + " \"generate_answer\",\n", + "]\n", + "\n", + "\n", + "def find_tool_calls_react(messages):\n", + " \"\"\"\n", + " Find all tool calls in the messages returned\n", + " \"\"\"\n", + " tool_calls = [\n", + " tc[\"name\"] for m in messages[\"messages\"] for tc in getattr(m, \"tool_calls\", [])\n", + " ]\n", + " return tool_calls\n", + "\n", + "\n", + "def check_trajectory_react(root_run: Run, example: Example) -> dict:\n", + " \"\"\"\n", + " Check if all expected tools are called in exact order and without any additional tool calls.\n", + " \"\"\"\n", + " messages = root_run.outputs[\"messages\"]\n", + " tool_calls = find_tool_calls_react(messages)\n", + " print(f\"Tool calls ReAct agent: {tool_calls}\")\n", + " if tool_calls == expected_trajectory_1 or tool_calls == expected_trajectory_2:\n", + " score = 1\n", + " else:\n", + " score = 0\n", + "\n", + " return {\"score\": int(score), \"key\": \"tool_calls_in_exact_order\"}\n", + "\n", + "\n", + "def check_trajectory_custom(root_run: Run, example: Example) -> dict:\n", + " \"\"\"\n", + " Check if all expected tools are called in exact order and without any additional tool calls.\n", + " \"\"\"\n", + " tool_calls = root_run.outputs[\"steps\"]\n", + " print(f\"Tool calls custom agent: {tool_calls}\")\n", + " if tool_calls == expected_trajectory_1 or tool_calls == expected_trajectory_2:\n", + " score = 1\n", + " else:\n", + " score = 0\n", + "\n", + " return {\"score\": int(score), \"key\": \"tool_calls_in_exact_order\"}" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "909b097d-cda1-45ff-8210-afeb2d18b8ae", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "View the evaluation results for experiment: 'custom-agent-llama3-8b-answer-and-tool-use-d6006159' at:\n", + "https://smith.langchain.com/o/1fa8b1f4-fcb9-4072-9aa9-983e35ad61b8/datasets/a8b9273b-ca33-4e2f-9f69-9bbc37f6f51b/compare?selectedSessions=83c60822-ef22-43e8-ac85-4488af279c6f\n", + "\n", + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "529952314cd34ac1bb115840536921c3", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Tool calls custom agent: ['retrieve_documents', 'grade_document_retrieval', 'web_search', 'generate_answer']\n", + "Tool calls custom agent: ['retrieve_documents', 'grade_document_retrieval', 'web_search', 'generate_answer']\n", + "Tool calls custom agent: ['retrieve_documents', 'grade_document_retrieval', 'web_search', 'generate_answer']\n", + "Tool calls custom agent: ['retrieve_documents', 'grade_document_retrieval', 'web_search', 'generate_answer']\n", + "Tool calls custom agent: ['retrieve_documents', 'grade_document_retrieval', 'web_search', 'generate_answer']\n", + "Tool calls custom agent: ['retrieve_documents', 'grade_document_retrieval', 'web_search', 'generate_answer']\n", + "Tool calls custom agent: ['retrieve_documents', 'grade_document_retrieval', 'web_search', 'generate_answer']\n", + "Tool calls custom agent: ['retrieve_documents', 'grade_document_retrieval', 'web_search', 'generate_answer']\n", + "Tool calls custom agent: ['retrieve_documents', 'grade_document_retrieval', 'web_search', 'generate_answer']\n", + "Tool calls custom agent: ['retrieve_documents', 'grade_document_retrieval', 'web_search', 'generate_answer']\n", + "Tool calls custom agent: ['retrieve_documents', 'grade_document_retrieval', 'web_search', 'generate_answer']\n", + "Tool calls custom agent: ['retrieve_documents', 'grade_document_retrieval', 'web_search', 'generate_answer']\n", + "Tool calls custom agent: ['retrieve_documents', 'grade_document_retrieval', 'web_search', 'generate_answer']\n", + "Tool calls custom agent: ['retrieve_documents', 'grade_document_retrieval', 'web_search', 'generate_answer']\n", + "Tool calls custom agent: ['retrieve_documents', 'grade_document_retrieval', 'web_search', 'generate_answer']\n" + ] + } + ], + "source": [ + "from langsmith.evaluation import evaluate\n", + "\n", + "experiment_prefix = f\"custom-agent-{model_tested}\"\n", + "experiment_results = evaluate(\n", + " predict_custom_agent_local_answer,\n", + " data=dataset_name,\n", + " evaluators=[answer_evaluator, check_trajectory_custom],\n", + " experiment_prefix=experiment_prefix + \"-answer-and-tool-use\",\n", + " num_repetitions=3,\n", + " max_concurrency=1, # Use when running locally\n", + " metadata={\"version\": metadata},\n", + ")" + ] + }, + { + "attachments": { + "80e86604-7734-4aeb-a200-d1413870c3cb.png": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABf0AAAFdCAYAAAC5CcfkAAAMP2lDQ1BJQ0MgUHJvZmlsZQAASImVVwdYU8kWnluSkEBCCSAgJfQmCEgJICWEFkB6EWyEJEAoMQaCiB1dVHDtYgEbuiqi2AGxI3YWwd4XRRSUdbFgV96kgK77yvfO9829//3nzH/OnDu3DADqp7hicQ6qAUCuKF8SGxLAGJucwiB1AwTggAYIgMDl5YlZ0dERANrg+e/27ib0hnbNQab1z/7/app8QR4PACQa4jR+Hi8X4kMA4JU8sSQfAKKMN5+aL5Zh2IC2BCYI8UIZzlDgShlOU+B9cp/4WDbEzQCoqHG5kgwAaG2QZxTwMqAGrQ9iJxFfKAJAnQGxb27uZD7EqRDbQB8xxDJ9ZtoPOhl/00wb0uRyM4awYi5yUwkU5olzuNP+z3L8b8vNkQ7GsIJNLVMSGiubM6zb7ezJ4TKsBnGvKC0yCmItiD8I+XJ/iFFKpjQ0QeGPGvLy2LBmQBdiJz43MBxiQ4iDRTmREUo+LV0YzIEYrhC0UJjPiYdYD+KFgrygOKXPZsnkWGUstC5dwmYp+QtciTyuLNZDaXYCS6n/OlPAUepjtKLM+CSIKRBbFAgTIyGmQeyYlx0XrvQZXZTJjhz0kUhjZflbQBwrEIUEKPSxgnRJcKzSvzQ3b3C+2OZMISdSiQ/kZ8aHKuqDNfO48vzhXLA2gYiVMKgjyBsbMTgXviAwSDF3rFsgSohT6nwQ5wfEKsbiFHFOtNIfNxPkhMh4M4hd8wrilGPxxHy4IBX6eLo4PzpekSdelMUNi1bkgy8DEYANAgEDSGFLA5NBFhC29tb3witFTzDgAgnIAALgoGQGRyTJe0TwGAeKwJ8QCUDe0LgAea8AFED+6xCrODqAdHlvgXxENngKcS4IBznwWiofJRqKlgieQEb4j+hc2Hgw3xzYZP3/nh9kvzMsyEQoGelgRIb6oCcxiBhIDCUGE21xA9wX98Yj4NEfNheciXsOzuO7P+EpoZ3wmHCD0EG4M0lYLPkpyzGgA+oHK2uR9mMtcCuo6YYH4D5QHSrjurgBcMBdYRwW7gcju0GWrcxbVhXGT9p/m8EPd0PpR3Yio+RhZH+yzc8jaXY0tyEVWa1/rI8i17SherOHen6Oz/6h+nx4Dv/ZE1uIHcTOY6exi9gxrB4wsJNYA9aCHZfhodX1RL66BqPFyvPJhjrCf8QbvLOySuY51Tj1OH1R9OULCmXvaMCeLJ4mEWZk5jNY8IsgYHBEPMcRDBcnF1cAZN8XxevrTYz8u4Hotnzn5v0BgM/JgYGBo9+5sJMA7PeAj/+R75wNE346VAG4cIQnlRQoOFx2IMC3hDp80vSBMTAHNnA+LsAdeAN/EATCQBSIB8lgIsw+E65zCZgKZoC5oASUgWVgNVgPNoGtYCfYAw6AenAMnAbnwGXQBm6Ae3D1dIEXoA+8A58RBCEhVISO6CMmiCVij7ggTMQXCUIikFgkGUlFMhARIkVmIPOQMmQFsh7ZglQj+5EjyGnkItKO3EEeIT3Ia+QTiqFqqDZqhFqhI1EmykLD0Xh0ApqBTkGL0PnoEnQtWoXuRuvQ0+hl9Abagb5A+zGAqWK6mCnmgDExNhaFpWDpmASbhZVi5VgVVos1wvt8DevAerGPOBGn4wzcAa7gUDwB5+FT8Fn4Ynw9vhOvw5vxa/gjvA//RqASDAn2BC8ChzCWkEGYSighlBO2Ew4TzsJnqYvwjkgk6hKtiR7wWUwmZhGnExcTNxD3Ek8R24mdxH4SiaRPsif5kKJIXFI+qYS0jrSbdJJ0ldRF+qCiqmKi4qISrJKiIlIpVilX2aVyQuWqyjOVz2QNsiXZixxF5pOnkZeSt5EbyVfIXeTPFE2KNcWHEk/JosylrKXUUs5S7lPeqKqqmql6qsaoClXnqK5V3ad6QfWR6kc1LTU7NbbaeDWp2hK1HWqn1O6ovaFSqVZUf2oKNZ+6hFpNPUN9SP1Ao9McaRwanzabVkGro12lvVQnq1uqs9Qnqhepl6sfVL+i3qtB1rDSYGtwNWZpVGgc0bil0a9J13TWjNLM1VysuUvzoma3FknLSitIi681X2ur1hmtTjpGN6ez6Tz6PPo2+ll6lzZR21qbo52lXaa9R7tVu09HS8dVJ1GnUKdC57hOhy6ma6XL0c3RXap7QPem7qdhRsNYwwTDFg2rHXZ12Hu94Xr+egK9Ur29ejf0Pukz9IP0s/WX69frPzDADewMYgymGmw0OGvQO1x7uPdw3vDS4QeG3zVEDe0MYw2nG241bDHsNzI2CjESG60zOmPUa6xr7G+cZbzK+IRxjwndxNdEaLLK5KTJc4YOg8XIYaxlNDP6TA1NQ02lpltMW00/m1mbJZgVm+01e2BOMWeap5uvMm8y77MwsRhjMcOixuKuJdmSaZlpucbyvOV7K2urJKsFVvVW3dZ61hzrIusa6/s2VBs/myk2VTbXbYm2TNts2w22bXaonZtdpl2F3RV71N7dXmi/wb59BGGE5wjRiKoRtxzUHFgOBQ41Do8cdR0jHIsd6x1fjrQYmTJy+cjzI785uTnlOG1zuues5RzmXOzc6Pzaxc6F51Lhcn0UdVTwqNmjGka9crV3FbhudL3tRncb47bArcntq7uHu8S91r3Hw8Ij1aPS4xZTmxnNXMy84EnwDPCc7XnM86OXu1e+1wGvv7wdvLO9d3l3j7YeLRi9bXSnj5kP12eLT4cvwzfVd7Nvh5+pH9evyu+xv7k/33+7/zOWLSuLtZv1MsApQBJwOOA924s9k30qEAsMCSwNbA3SCkoIWh/0MNgsOCO4JrgvxC1kesipUEJoeOjy0FscIw6PU83pC/MImxnWHK4WHhe+PvxxhF2EJKJxDDombMzKMfcjLSNFkfVRIIoTtTLqQbR19JToozHEmOiYipinsc6xM2LPx9HjJsXtinsXHxC/NP5egk2CNKEpUT1xfGJ14vukwKQVSR1jR46dOfZyskGyMLkhhZSSmLI9pX9c0LjV47rGu40vGX9zgvWEwgkXJxpMzJl4fJL6JO6kg6mE1KTUXalfuFHcKm5/GietMq2Px+at4b3g+/NX8XsEPoIVgmfpPukr0rszfDJWZvRk+mWWZ/YK2cL1wldZoVmbst5nR2XvyB7IScrZm6uSm5p7RKQlyhY1TzaeXDi5XWwvLhF3TPGasnpKnyRcsj0PyZuQ15CvDX/kW6Q20l+kjwp8CyoKPkxNnHqwULNQVNgyzW7aomnPioKLfpuOT+dNb5phOmPujEczWTO3zEJmpc1qmm0+e/7srjkhc3bOpczNnvt7sVPxiuK385LmNc43mj9nfucvIb/UlNBKJCW3Fngv2LQQXyhc2Lpo1KJ1i76V8ksvlTmVlZd9WcxbfOlX51/X/jqwJH1J61L3pRuXEZeJlt1c7rd85wrNFUUrOleOWVm3irGqdNXb1ZNWXyx3Ld+0hrJGuqZjbcTahnUW65at+7I+c/2NioCKvZWGlYsq32/gb7i60X9j7SajTWWbPm0Wbr69JWRLXZVVVflW4taCrU+3JW47/xvzt+rtBtvLtn/dIdrRsTN2Z3O1R3X1LsNdS2vQGmlNz+7xu9v2BO5pqHWo3bJXd2/ZPrBPuu/5/tT9Nw+EH2g6yDxYe8jyUOVh+uHSOqRuWl1ffWZ9R0NyQ/uRsCNNjd6Nh486Ht1xzPRYxXGd40tPUE7MPzFwsuhk/ynxqd7TGac7myY13Tsz9sz15pjm1rPhZy+cCz535jzr/MkLPheOXfS6eOQS81L9ZffLdS1uLYd/d/v9cKt7a90VjysNbZ5tje2j209c9bt6+lrgtXPXOdcv34i80X4z4ebtW+Nvddzm3+6+k3Pn1d2Cu5/vzblPuF/6QONB+UPDh1V/2P6xt8O94/ijwEctj+Me3+vkdb54kvfkS9f8p9Sn5c9MnlV3u3Qf6wnuaXs+7nnXC/GLz70lf2r+WfnS5uWhv/z/aukb29f1SvJq4PXiN/pvdrx1fdvUH93/8F3uu8/vSz/of9j5kfnx/KekT88+T/1C+rL2q+3Xxm/h3+4P5A4MiLkSrvxXAIMNTU8H4PUOAKjJANDh/owyTrH/kxui2LPKEfhPWLFHlJs7ALXw/z2mF/7d3AJg3za4/YL66uMBiKYCEO8J0FGjhtrgXk2+r5QZEe4DNkd+TctNA//GFHvOH/L++Qxkqq7g5/O/AFFLfCfKufu9AAAAVmVYSWZNTQAqAAAACAABh2kABAAAAAEAAAAaAAAAAAADkoYABwAAABIAAABEoAIABAAAAAEAAAX9oAMABAAAAAEAAAFdAAAAAEFTQ0lJAAAAU2NyZWVuc2hvdGE8+poAAAHXaVRYdFhNTDpjb20uYWRvYmUueG1wAAAAAAA8eDp4bXBtZXRhIHhtbG5zOng9ImFkb2JlOm5zOm1ldGEvIiB4OnhtcHRrPSJYTVAgQ29yZSA2LjAuMCI+CiAgIDxyZGY6UkRGIHhtbG5zOnJkZj0iaHR0cDovL3d3dy53My5vcmcvMTk5OS8wMi8yMi1yZGYtc3ludGF4LW5zIyI+CiAgICAgIDxyZGY6RGVzY3JpcHRpb24gcmRmOmFib3V0PSIiCiAgICAgICAgICAgIHhtbG5zOmV4aWY9Imh0dHA6Ly9ucy5hZG9iZS5jb20vZXhpZi8xLjAvIj4KICAgICAgICAgPGV4aWY6UGl4ZWxZRGltZW5zaW9uPjM0OTwvZXhpZjpQaXhlbFlEaW1lbnNpb24+CiAgICAgICAgIDxleGlmOlBpeGVsWERpbWVuc2lvbj4xNTMzPC9leGlmOlBpeGVsWERpbWVuc2lvbj4KICAgICAgICAgPGV4aWY6VXNlckNvbW1lbnQ+U2NyZWVuc2hvdDwvZXhpZjpVc2VyQ29tbWVudD4KICAgICAgPC9yZGY6RGVzY3JpcHRpb24+CiAgIDwvcmRmOlJERj4KPC94OnhtcG1ldGE+CvHPuSEAAEAASURBVHgB7J0FnFVFG8Zf6QbplhBp6ZCUELFQDFQUBETsDsxPFEwMFFBUEBBRJKRLOgUEpKW7uzu+93l3z+Xs5e6NvbvLxjO/3+49MWfOnP+cM+fMM++8c80lDcJAAiRAAiRAAiRAAiRAAiRAAiRAAiRAAiRAAiRAAiRAAiSQ6AmkSPRXwAsgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIwAhT9eSOQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQQBIhQNE/iRQkL4MESIAESIAESIAESIAESIAESIAESIAESIAESIAESIAEKPrzHiABEiABEiABEiABEiABEiABEiABEiABEiABEiABEiCBJEKAon8SKUheBgmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAlQ9Oc9QAIkQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAJJhABF/yRSkLwMEiABEiABEiABEiABEiABEiABEiABEiABEiABEiABEqDoz3uABEiABEiABEiABEiABEiABEiABEiABEiABEiABEiABJIIAYr+SaQgeRkkQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAIkkCqmCM6euyAnTp2VM2fPyfkLF2OaDI8jARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARKIJQLXXNIQalqHjp6S0yr2Z0qfVtKkSSkpUnDAQKgMGZ8ESIAESIAESIAESIAESIAESIAESIAESIAESIAESIAEYptAyKL//kPHJWXKlJIpY9rYzgvTIwESIAESIAESIAESIAESIAESIAESIAESIAESIAESIAESCINASKI/LPwRKPiHQZyHkgAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkEAcEQjaLw98+JtLH1r4x1FRMFkSIAESIAESIAESIAESIAESIAESIAESIAESIAESIAESCI9A0KI/Ju2FD38GEiABEiABEiABEiABEiABEiABEiABEiABEiABEiABEiCBhEkgaNH/jE7ci0l7GUiABEiABEiABEiABEiABEiABEiABEiABEiABEiABEiABBImgaBF//MXLkqKFEFHT5hXy1yRAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQQBImQBU/CRcuL40ESIAESIAESIAESIAESIAESIAESIAESIAESIAESCB5EaDon7zKm1dLAiRAAiRAAiRAAiRAAiRAAiRAAiRAAiRAAiRAAiSQhAlQ9E/ChctLIwESIAESIAESIAESIAESIAESIAESIAESIAESIAESSF4EKPonr/Lm1ZIACZAACZAACZAACZAACZAACZAACZAACZAACZAACSRhAhT9k3Dh8tJIgARIgARIgARIgARIgARIgARIgARIgARIgARIgASSFwGK/smrvHm1JEACJEACJEACJEACJEACJEACJEACJEACJEACJEACSZgARf8kXLi8NBIgARIgARIgARIgARIgARIgARIgARIgARIgARIggeRFgKJ/8ipvXi0JkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkEASJpAqCV8bL40ESIAESIAESIAESIAE4pTAuo1bpUSxwnaO8ZPnyrhJc6VE8UK6rZBtu61xrTg9PxMnARIgARIgARIgARIgARIgAW8C8S76nzlzVg4fPCwnT56WS5cueecnyvo111wjGTKkk2zZs0natGmi7OMKCZAACZAACZAACZAACVwtAhD7x0/+W9Zt2CYvPNnChP91G7dZdiD4Q/x3AoV/hwR/Y0pg/4HDsnnbLjl0+Ki2oUSyZc0kRQrlk9y5ssc0SR5HAtESQP2G4HRoRhuRO0iABEjAiwDrDy8gXCWBq0ggXkV/CP47t++W3LlzSP78uSVFCv/ehS5evChHj56wY/IXzEvh/yreKDy1yMrVGxXDJSlbqjhxkAAJkAAJkAAJJGMCaNB++8NgI3D7LbWiCGOw8ofIjz/H8h8dAE7HQEywQeQ9e/ZsjL6FDx0+JkeOHpOC+fNIqlQpY3J6HnMVCezdd1BmzP1Xdu7ZJzfoiJIc2bMKDKMOHjwiCxavlOfat7iKueOpkxoBd2emc22o49hx6dDgLwn4JrBy9QbbkZy1goRef5w6dUb27DsgOXNcK5kypvddkLG4ddee/XLh/AUpWCCPpcrvsViEG0tJbdm2U9KlTSt5VKOOj3A16ol4Ff1h4Q/BP1u2zEHxRKeAExfH5smXO6jjYjPShQsX5KW3v/aZZKUbS0q7R+7yuS8+Nq5as1F69f1THrq3idSqfmN8nPKKc4DPhk3bpeh1BSR16itvp9XrNkvP3kOlXJli8uRj90Y5vt/vY2TRktXyZecXJU2a1FH2JbQVCP5gjfBU2+YU/hNaATE/JEACJEACJBBPBBzBP0LcvymK4O+dBUf8//bHP6yToPtnr3lH8bsO6+5Bw/+SLdt2y+nTZ9W6O7OUK11M7rurYdAC/sy//5XJ0xdIp45PmGDs6/vx2PGTAnG5eNGCfvPDnfFLAN/Rw8dOl8b1q8sDdze64uS3yk1XbAtlg692TqZM6aVAvlxyZ5M6UqRw/lCSCyvuHr3/YPCVL09OS+fcufPy6nvdpErF0vLYQ3fYNl/36Rc9B8qRI8ek89tPhXV+HizirtucTkqn4xJ8QhX+T+jI/rc7f2fl+sGbHST7tVmIOQYE8Fz0+32srFBR+dzZ8xLqeyQGp+QhIRKAkNer73A7KrlqBbFRf0yZ+Y+MGDsjWvr33dVAbq5TJdr9gXZs2rpDvv/5T2n5gL49q5YPFD3s/QOHTjAj5g/fetLS8v4eC+cEo8bPlMkzFsh7rz0uuXJeG05SV/1YX+/2+MrUV98NkhuuLyTPPv5AnJ/yatUT/k3tY/my4dInS5aMIaeKY3Ds1Qx582SXZk3rRvmrWrHU1cySZMmcUSqWL2kNuKuVkR279kr3n4bIYf3Y9hdWrNooS1as9Rclwe5zBP+qlUpL1Upl7IXu9NAl2EwzYyRAAiRAAiRAAnFCYP3G7ZbuCx0e9Cv4u0+OuAgQ/4MNED0/7zFAtu3YKw20kftkm+ZSvkxxmT1vqfQbNDbYZK6I5+v7ERbjfX8bfUVcbrh6BHarheCw0dPkYTXuqabfn4HC7HlLZNL0+dpBtCtQ1Cv2X1c4n7R79C77q1G5rGzdvke/7wcH/L6/IqEwNgwfM00mTp3vSSFFimusnQMXRk7wdZ+WvL4wjXEcQGH+wl0ZrPrddRuEfnRwut2VBXuaZavWqSuqi5IyZYpE2w4M9lrjMt7aDVvl32VrpH6tyvLuq23j8lRMOwYEHCEvQisonWy1gtioPwoVyG2iPoR9GI0i3KB1PNbxV1C9hTBEEMiXN6e9I5OCG3Rf7/akVs5Xs5640jQ7DunCh38glz6+To9jAvn/93VcbG6Dv8xbGtSIzSTDTgvDtK/mSANcwI7d+4O+jmGjpkrpEkViNDQ96JPEckRH8EePPRpACE+1vdes/pNrL34sI2ZyJEACJEACJJBoCDhWrxDGQg2wnIVLIFjDBeMnG/FOnTwjTRvVVCGutp2uXOni+u21T1bpCMTz58+rtX/on/K+vh93hvA9F+p1M37MCExXlz4o+2Cs7U+dOi1TZi7UkbOpZMeu/dLm4QjL+GDPjBEkldSQCAG/GL07Yco82bhlh1S+MX6MnHAPFityeaRJypQpr2jn+LpP77q1brCXyXgBCDidk97Rbmt8k81dEmzd5RwPobpwobySPl1aWazLDetWdXbxNwQCB9SVFwI6uOLLBUUI2UvWUR0hL6pW0NyE/+SmFcRG/XFD8esEfwjLV60XGI5WVu8atWtUSNb3ma+LhzFAMAYBvo5NaNt8vdsTWh7Dyc/VridCbymEc7VJ9FgMu121ZpN0aH2PDa3B8JTv+gyR/OqOqFWL29T9zTb5/c+/pIF+6GzYtMMqsHx5cuiogXpyvU70hoBOjXGT5sjSlevkzJlzUqZkUWl+x83m9gaNuk+/6W8f3el0QuNJOozniVZ3m9XEgMHj5S5Np0LZEjJVh0PN/WeZHYc4O3bukxt1+/06DGqICu4QsHPnulYee/AO9WOWzc579NgJGfPXbG08bpLMOpwXluyN6lWzfU6+b65dRdas32qWQwXy55KHmjeRrFkyyW9DJ8ry/9Zb3B69h6iLn/zayLjT1r3/VdFREYuXrpbRE2fL/c0aeu+2dQxdHKP7MSIADPFRc89tlxn9PHC0nDh1yoZi/TVtniDvTRrUlPLaAP7tz4myXS3hypQsZswdn7Wbt+60YU/r1QVRAS0PWMqhwRxsKFuqmMedjyP6R2y7V62KInqfIQAghDrkNdg8MB4JkAAJkAAJkEDCIhCTdz6EfljMwhquRIfCAS8IrjEQTp0+EyVu+0fvFoi811yTwoR/fCOWvqGoZMmUUabOXigZM6QTfLvVqVkxynHOCvyXur8fP/66nxxQN5rn1e9s5y/6SN2aFdSirqrAF+2QUVNk+869kk+/yapWLCN1b/KdppM2f2OHAFwt7dcyeaj5LUEluHnrLms77N1/UG7TjoJwA/wdI5w4EXEPBtNOCXQPRvdNvn3nHnVdMkYnKD6mbZUNdg8++kBT7ewoIB991UfbODdoW6euRHef/vLHOJ2z4rg8/0TE3AYQSMdqm2qNukaCm9galctJvVqV7HoCtW0QKTne9xDzrV7Sdun1xQpe0SnpjG4KprPSQOs/1FFrtf14u44USJ8+nQwZOdnK+NpIN79O+7Zc6evREJYly9dKFp2cupl24jjtY/jf/mPEZFmv+UuXLo22+a63DtC1uo6RIXAdC7cWFy5clM+7/2LlXLt6hDiItjfui6faRLiX/effVTJnwTLZs/eApl9Y3VfVljyRk2CjjXn6zBlrA/8xfJLUqFJObm3o+zlCG/WbHwbJLTdXt3i43k3a3hw4ZLy1kZ28Oxzcv05bvbW2xYeNnmrtfLiU8Pd8/dD/T9mq7t0QBg6ZKFmzZpTXnn3U1mNyTeG0/XFSuAQbPWGWagAb7J1RpUIpez4xzwiCv/Qtgp9/0ZW340J4nY54gPuXTVrf5c+XU+67o4HHVzreX6M0X6hDoCmgvX/3bfXNDZ5zr6ED062loJMxunrJTzaj7IL/fkfcv6wVXN6GyEldK4iL+iMKZK8Vf3U8ogba75VcwNWDh46aXoZ3Smb1tAGtzC22w0p96qyFsk/dMea4NqvUqXGj1kWVA6brRECH6GQdpbf/0BG5Xl0s1rupkpRSQ9lAYebcxQJ3Qc8/8aBpc6jHjp88KTW1/pqkLh3xSNatWSno7zZ/9VAgvTOQjuev3oju3R7o+teu3yJTlDtGNxbSORNQLg636Opa5GOo6qLLVHPFCIl7bq9/xWn81QnRpXtFIl4brnY9Ea/ufbyuPVGtHlOB+b+1m6L84QMDAVYLR44dl1/1ZY+H5Q/1vbpn3yEVpCNGBpw5e04/MA7JyHEzdftBqyTwUvhZh1HjwwEBwvtf0+bb8NTaWlEsXPKf/DbsL9unSdrxeLmOVYEZgjssu5x0T0c2Bo+dOGXxBg+fLLlzZLeX2oJFK+WDrr017ll9GHLL5i279EafYuni4UQeVv63UTskqkjRIgXMh9qcBUttv5M+HnLNgmTXicPQ29pXP8wRMNQqd6T/sArlSliD03b4+FdMOwTQ+JypVktbdTJnX2HKjH+sgkJHBVwpHdMPte/7DrMPCsQ/ePiIbNy8w4YuFy6YTye0O68ffNN1qPxgyZk9m/m5RcfCDK0AEeBy6If+w+WQ/uKDE8OEcb07tPEaSvA1GY8j+IeSDuOSAAmQAAmQAAkkbgJwcRETK/+YXHVxFSRSpU4pM+b8K9/+9Ie69Vki+/YfUiONDGrEkd2MP5xvxPn6vYfGHxp76CwYPGKKrN2wxedpne875/uxmvpMT58unQlQcO1SQIfPI92eatBxQr8t71VhBYYYEO12q2DGEPcENmsjtkQI8yuUVmOhetohc0PxwiaIhZNDzCMxa96/lgTaDgjBtFP83YP+vskzZczgGU2ASYpxD2bJnEnPesnaNWhjIfi6T7Ed7QPkGeGstrl+GjDC2ms11V8z0h4ycorMW7jC9jv3fnRtm+R230Osc+YbASDUbxiN5IiUBi3yHzosQwnL1EoXbeXyZa83t2Rgu3TFGk8STt2FtuFGFc0LFswr27R9jLYfyhHhjxGTTMSFkRfKc+qsRTJ/0Qq5TtuBe/cdNqM7xNusfrp36ggXdBwgoI2LNmGuyM4rtOEH/DFe686M0lTF/F2798qP2kY8c+asxcc9tGv3AflF3aZhhIm/CT5R/6IDAoK7E5bqeY8cPaEdVZddUTn73L9OW906JI4cl2uzRcxx4O/5gngN91sIKANn5E1Mrinctj/yMFifJ4wqwrNa6oYiZlzn3C+B0sfx/kJ05Y1joKH8+MsI2aI6AjpljquG0h3vqMjO8cH6fpo+e5HVgRD+Zs5dYvPh4FjnXvPWUvzVSzgu2OBbKwjeyDDY8yS0eHFZf0R3rYHq+ED7o0s3uu1ws/jjL8PNvVZZfRbx/A/QjmYIzgjo8EPdgvlK7te5ltKnT6vvnKmqWW2PLsko29EJ2U/1qWv1+PvubCgntaNz4JAJVndGiehj5Xik9udokqjHNm3eqaP0/pbCWp+iA26wdpqisyyY4K8eCqR3BtLx/NUb0b3b/eUZ36I/DRipHclHrZME9W9vXd+lI2ERoqtrx/41x1xkQtdEx81InRcBLuicEKhOiC5d53h/v1eznkjlL2Pcd5nAJhXLv+sz7PIGXfrkf8/aRwFEeDykv6rVfa9+f5rV/D131PdYDzgH5cqZzXrm0euGSarsIdSPrXLaQzxp2gKpX7uS9kjXs+j44MAkJrCKTxs5yS2sFd5/vb358kek6BpzLZo3ts4DVDZffz9Ih8oW0JEB99gLr/MXve1lieMxOdgG9UvbvvXdNlIA2w6qdcyMOYvFsZLAtto1Ksq9d96MRfmkWz/Zor3r6E2vqo3EbTv2aKW2U3sRKwacQARCPnrVBqnlxWvPtbL03P9y6OiDlvfrpCrVIiZVwYR16LHftWefdljktagXL1ySl5582CrUXBofIwMa1atqPt7wkL738Q+yOdIaYoZ+RJ7UYfHvvHK/lRMmO3734146GmK5z8nQ3HnhMgmQAAmQAAmQAAnEhMC6Ddv8+u7H/mACGpGPP9LMrJLWrd8m+EOA8NNCJ3XNGznhKbZhlOgHHTvY91GNquXkoy/7aiN1rWeYPOJEF+C+8t/la7SBeEmaRFq3wigFjSgMqa+p6dWoUtZGdMJKiiHuCcDqPYcatIQS8mjHTPZd+6xjKJTjEBeTO7//yQ9y4eIls47GNpQ9XAtBRAmmneLvHgz0TQ4LPVia582d03MPwpDKHXzdp+79WMYIZIx0btPyDqlSobS2fS7ZCIHJM+bbfezEj65tg1E1yeW+N8FOBX7UJ+6JYR0B12GFdXQGwD1ZKAGufSAMOxMzF9QOJFi0YhSRO+TNnV1efqqlWaXCAhPt0C3btdNLrfExd1yhgnk8IzUwUh4W5RDl4TboP23L1q9d2UakYztG1MOqe5saeKEdWbZUUTsVRn4UUMvwdi3vsvMUVWO0rt0HWucQ5sdDQDvyhQ4tlEfgUVhV1GIcYhEs0yHyoYOjfJnrg3a3hlHqjsu2QM+Xtcn1UVi+coO5OXFGrMfkmvCch9P2P6mjN+bOX2ZtdbTZEaBTrFFREdcTrLZgB/r4F115I+o07fBBmXZ++0kz9Dt8pIp8qZN4r1ePCkW1nvp7wXKrsx50jY7C/DfwrAD3UgjeWgrKkFqBoQn5X1zXH9FlKFAdH2h/dOlGtx3zkuCd0urB26S6dkjjnfJ1r9+17tisBrDXicp60uy2uja6EiNS8mod9VXP30yPcruriy59uMrGq66Bjs7EKKHS2pG2Qg198ayhgyHUcFHf4a/qSCCM+Fyq3jN6Dxilz8j2gPVaoHookN7pT8fLmiWz33ojmHe7N4fpsxcLOmSebnu/dp5mFuh8nT77SY1floi7DnDXtUjj74XLtf7IJK8+84gliXdBz95DrVyxIdC3ih2k/7zTdbYn1F+K/kGWTNHr8pkrGXf09NrL7wQ0htBggtU84vryWViiaCH70MAxjrXEnr0HJbv28qMCgY9WdAQgHNThPQjorXJ8eeKmxORrgYLTSMADhpDj2ohGAzob8PG1NrLRuEMbBghLV6zTIbBbbBkvQ4xKcDfqIK47Ab2GsKTAR7G7IvL+MHfiu3/T6Qv3fm2k9tHKB8ORvMONOjkdLHH6/jZGDh89Jod1KBXCOe1gcEKGDGnt4wrrzqTQaBQjwB8p3PqcUhdACPhwSK0WcnCb5AR8EIIzAwmQAAmQAAmQAAnEhMC6jdvktmgOhO/rEtpwQ5zoQigjBSDwYHQhrMnwrbZo6X/mWxsjGd99tZ3nFHC/CPEJIa+Kv5kzZ5Dd+0KzykfD0wn4xitWtICJfRBykAc0ePGtxRD3BPBd7bjLCOVsMT0ui1rEl1TrWISFS1ZJvrzqzvPeCNdCO/W7OZh2ir97MPhvctdNaLm58p/7PvXeu13FGQTHJzQYwl3CHBUqIRA4wV/bJjnc945gh7rIcVXmiP3OOlhhFAA6KSH4h+ba54wJ8TA8Q/sYAUIL2skQ1931CFxJoY2KUFgFfgRnJHzFcjfY3BJwOwaRpbK6kkFbFKGc1klwZ4s2K8T/GlXLyrx/VpjABXdXadOmtroY9+4uFdZwToxWQnAsY+FH2hH902sbMxjBH8dXUh/jGC2yUkV0TCy6b/9hNZBrgF1BBYyQd0Kg58tXnmJ6TeG2/eGKCwGj/Z3gvu5A6cOo0V/wV97bd+0xN8XOvYPfzm8/ZcmhMwPhhusL2S/+QWuB6I+653rVYBC8tZTg6yU7nP8iCcR1/eEPdKA6PtB+f2n72uekV1IFfgS8U155uqUnKnQ6WNxjlMpBtTo/fjxChzrvet94IvtYKKMifxqtq3r+PNRc9MHFdzV1pZgm0ujXxyF+N0Erg+CPAM8YCLD4DxSCqYf86Z3+dLxA9YaTN3/vdieO84v6AO7KHXdxqA+wvl2fd3dw17UYFYTyqaKGy05Ah6E7BFsnuNN1H59Qlyn6B1kyWVRAd3rWfR2Cm/ScWhYgnNehjOhlS5ky8gsm8oCMapXghDSpU9siPjpOaE8ewjXoK4w8BENO6taqaMMHbaf+S5nC/4vSiRfs78nI4XDWqIg8L1z84A+W/L6C5dHXjiC34WVevmxxGyZcIF+uKEf1HzTOLI0ihnCWtY9FDBWKacCD7b42pIOPNPi8ZSABEiABEiABEiCBUAk4RhvRHWd++9VCNbpOgeiO87cd3zLFritgf00b3eQZVQohC9bdCN7uKNKoG0hH2PKXtr99z7S9z1wmLlyy2kZWTpw6T1588iGP6ObvWO4LjwAasDAAwtB/p4yDSRFzMzguQ4KJ78SBa5WH72tiqxAUYYQDP8YwrAm2neLvHoyvb3JYXiOkUYtLJ8AlKq7Je24MZ7932yY53PcYVeEW/B0WsOjHH+o5iP34DVXwR1qwtkVbEj798ecOsD6tr1atwQRYj+P+nz1/iVlgwq1Mi3sam49qWPHDVQPmrIPP+3vUf/t2HYG+eu1m2awuYEqWuM5c9cCCFR0+1rEQ2d5NmSqFtbPz6CgDJ6RMEbzXYzyfEJCXrVxvzyk6DGChG2xwi9/BPl/utHE9MbmmcNv+p9TSHsH7WXfyFih993U7x7h//ZU33NE5Yqb7GCw7z3Zq18T2qSI7GOAuxQneWkp81UvO+ZPKb1zXH/44BarjA+33l7avfbjv4CI6g85L4ivAPRlcyNVS99yw1ocLuf6/j/UV1ec2GMW+83Jbc5O1fNUGWbZivUD/6vhCa/M57/OgIDc6nanBRA+mHvKnd/rT8QLVG8HkzzsOytm7YyTC+DdCV3Xiu+scvAsQHC8qWMb3gTsEWye403Ufn1CXo15lQs1lIsgXLNfXrttqFgjwIThhyly5o0mdKDnfqhPNOmFDpJ8vfGwUyh9h1VBcxXZnqB965OD7Pnuklb5zXGz+YpglQk0dpeBYEWDyKkx+kibN5VEMsXlOpNXi7sbS5cufzS2QkzY+XDDiAFYazsRJmMQsnACuO3U0A3zROhP7omfa+QgIJ20ci4mCvH1z4cOT/v7DJcvjSYAESIAESCBpEsB3SLAWs8NGT1Pxdbk8+/j9nlGf6ADIkyuHuZJEY9EJ+N6ByJ8yZQpzYXBABdsbVPRyBwifwQZ8h8I6CxMCwxgDcwl83n2AWUw7lrbBpsV4oRMoqj68h+pEn4fV73e50sX8zpvlTn2duu2E66dwQq3q5eVvdYWJOb7u0klVg22n+LsH4/qb3Llex6AIk08Xj5wTARaMmTKlD2q0dHK5703Q1xFJ7gALf0zii0l7MVIpJmK/kx6s+1EXPaITMuPXCYP+nGQufoIR/a3TQOclwdwmcCmLiYHh73+aTlaOCcUL5s+r89xllNHq6hXiD0R4tMsWL1ttEwY/cE/Ec4B9mOw3kxp9oQ2KYKMDtHPAmZvOyV8ov5jAFufG5NkVdD66mIpAwT5f7rzF9JrCbfsX0lENCJhjz5kwE77NYeHfQOc4DCf9wOWdx7QCuG+CUIf33SSd/BQjPgrki8gX8gE3SwgYxYHg1Am24vUvruulpKoVxHX94VVMUVad8oyujg+030ks2O8hjOSBMS8md3X0MrwfM+jIygpqzPqPjoyDJ42H743oNIeluHfwdS5n227V3o4eP2GdmejQRP3Vd+AYcxnmnizYO83YXg+mHopO7wyk4wWqN2JyLXjmMa8Jzg23SvjF3D5lShaLNjm8L9CBs3nbTk8cGEq4Q1zXCe5zOcvxUU9cfgs7Z+WvTwKwtMGkGPiDpRP+MGEVAvbBJ1y5MsWkbcs7zc8dJuVF5eAOy1TUnqV+ppar37+/ps3TD5RUZrUFlz3F9SNruvowxD4c1+fXkTJA5whwW6q404qNZTQ6Mfx7+LgZsmnLDntwMIwTE8EF2zPo9Hpu3LLTOguCyResI9CIcAd8KGEY5iZNBw8sKkxn0i13vFCWK5YvYRM5YbIkNFwxAR4mp4Jfs5gEfAw7Q14h7vfqO9yEfyetiG1/Rtnm7OMvCZAACZAACZBA4icA9z1o8DquMEK5IhyD7xAI/8GEqhVL6ujRC/pNOMoEWIgrEDnmqNUr/FxjKLMT4A5j6Kgplja+exBKRYr+jlUTLGzRMPIV0utw8FNnzqjByS5zrYEG6Q/9RsiwMdPMHQeGrUOUyRHpUtFXGtwWewTGT5knZ8+ds/m7ihSKGKIfKHW4fsI9gUmewwlwV5Avb051lbLcxNFg2yn+7sFA3+SpdQQ0Jq3erw1wuDZ1Jlj1vg7v+9R7P6ytMcnqn+p6Bc/L1Jn/mKU5BNpgQnK47536BwK/d0DbEG2dFzo8GHTnpHcaKLvVa7fYJK8QrTDxrPN3o07qi7Ye3MkGCjDYGq7z2/UZONImcT2sx8Bq23HrirYqBJ7dew5ISXU3k0It9cuULGKudlBXlXWJPyh/+LKfNmuh+ufeaxNt/tBvuPnNDpSP6PbDLRDmsYC/78o6kjymIdjnyzv9mFxTuG1/dJ7k17kR5sxfar6xN6p+MGDwBNmqIywQwkk/UHlXVJdIKNdfdNJUGEaOmTjLRnqkTZtGO2+ya52VQ7WURTqZ8xpZqnMITtNJfQuq2zvsiy4EqpeiOy667VG1gg1JUiuI6/ojOrbO9kB1fKD9aSMNW/9bs9kzCbSTtq9fdG7hnQJ3XnB1iAm80XkJi3CEjDoCAHPwbFB9CfXaZC8vFTgftq/XjlTYXXh/j+3U+qv7j0Nk7oJl9q11WNNCQEdCfIZA9ZA/vTOQjheo3sB1Bnq3e7PAs4s5PgYNn2Ts8Yv6uHKF6OtivCMqlr9BvzEO2OhVfCP8PvwvyZjx8iiO2K4TvPON9atRT6TylZG42gbrJMzqDuChBBxjblpCOSiW4+KDAkMI3aFYkfxmedBfZ/CGf/+W9zW13Zh8F5PK/KLb33zxMc8hDepUVkF9sX6cHDS/gq0evN3zQD/1WHP5ZfA46ff7GJ0w67xOApJdnmzT3NNz5UkkFhfwcD+n1mMDh02Ubr0GWcoYCtnyvluDPgs+OBYu+U9+GzpBJ1TKpxMVR0yKESiBerUqWc/olq27LSp63ZrrZMHDdAKnDz7vLfALesvNNXQ28zGBkop2PyppMIZP/wXaQZNaO1lu1jJoUCe4IaXRJqw7YM3/VNt79WX+p1StBL9g19hw2KfaNr/C+t9fOtxHAiRAAiRAAiSQeAhA1IDLC7jAgGiG9WACGso4Bi41gj3mukL55Zl298noCbPkD21kosGIxgmsy7ytucuoq4sjx45bpwIaqBg1CaENAd9qaFCOGDfTBGEYWXiHm2tVlt1qGYnJLW+5ubpOTFdPWj90u/ypow0wcSO+3cuWLiq1a1b0PpTrcUAAbQYYAaExnT4atwLu0yIuDJIwUWlshDrqqmDIyKkmnuE+Cqad4u8eDPRNjnYAJvPFJK4ff91fnnn8Po8lsft6fN2n7v3o9Hii9d02+XWP3kMknVpjYmJrt99xd3zvZUxWmNTve6f+gYuOEh2i1l/omDQrfxX9YxowqS3EWdQ73gHi+PyFK22CyZuq3ei9+4r1x7QOGjhkgnT54mfbB8H53jtu9sSDix9Y3ZZWP9gIRQoXUPEoreTQ+fJQlk64rXFt6/D8SztN/xwz3UZ+wJ2VM2+eEy+UX7Sjry9e0OYLcPx9h3K8O66/58sdz70ck2sKt+0PPebZxx+QfoPGyODhk03XgX//+5tFjKoIN31/5Y1OlgfuPqkd3wv0PfWrlSEmV4WgiIB89VUdpZ+6VkE+MfLjsYfuMMve6OafD1QvuXmHuoxRJ0lRK4jr+iMQ50B1fKD9eOYxb8uS5WvNH3ygdwPE96fa3Gs++7/rM9S0OehYNauWt6zim26HzncJLQ0jyvAOXqQuEZ2AUUl4P3/zwx/yeafnr/geQ2dWk4Y1bGTfuWHnzSi4SYMaNjm1k0Z8/UZXD+H7L5De6U/HC1Rv4PoCvdu9GeC75Kh2psDlG3Q++Pa/766bBa7E/QWUN76V8b0EI+w6+k2bV0fP7jtwyA6LyzrBV77iq564Ri0aghrru33PYcmTM2LCVF8ZDmbbHrXextC6bFoooQT0eB3XYS95IoduhXJsQoiLyWW+//lPHbbTSG+sSjrZx8kok+C684ihaqfVQiI6n3XuuLG5DKsMPNAYHhOTgI87DN/EQx1OwPAp+OWL7etHb2x6HQaPRkVsBse6H2lS8I9NskyLBEiABEiABBImAQj4sNg3f9dBimMxnRDTIQCXBvCLigl23QGW+6+8200qqpj2+CN32YRyGHbuy8AG30IYoenvU81xneA+Byy4kWZM3Ve40+Jy7BOA5eFkndC0uYqhaLDGZfDVTgnlHkTe/H2To1V64UKE+w5/1+HrPvWOD5+/6ACLadskKd/3EPedTkhYHaJOQycARjGF49bHuwxiax1+tVGOsOoON2DSzeh80jtp4x6FazVPiJRL8ubJ4de4K6bHOefx9Xw5+/z9BnNN3seH2/bHcw8ZCa6GfAVf6WOUxWq1rvWESK6wzs7v0nkClbe/63VGs4Wqafirlzz5jcFCUtQKEkr9EaiO97cf9yfcREG/mqVeLs46oyAj70nUNRCE3QEuxrDd1/eVv3sSzwms0tPrd5QTcL+5v8cQB+8cfOM576xw6xPnXM7viv822KgpZ90sSXSlVvUKUfIW03ooGB0vUL3hvNtDuXbEDVU7xL0BXdDfOwXpxoV+6OHvWojreiJmCq8rg6EsZsueTXbqcCyELOZTyb/FPyz8jx49IXvVfU5+nWAqKQQ0tLwbbO7rQsUT6k3rPj6my/5u+GDSdHzmBxPXXxw8fHFx/XGRJq7DsfgXueT3I9DfNXMfCZAACZAACZBA4iEASzcIYxD+n+/4hc8JMZ2rcRrHWA9HTEPjNHOmwJ/t/sSsYL6FcB7v4O+71Tsu1+OOQI/e2tFUtJBkV8tDCASYg2utirX58+TSDp9mYbv1CSbnwbRT/N2DOIe/+xDtJF/3oHfegonjFli8jw9mPSnf9xD6ESD84w8hppP22sFx/M89f0m4pwp0fyJ9iM4LtTPNu4cU7T7v+dzc+YnpcU4awTxfTlz3bzDX5I6P5XDb/oFEdV/p71VrWl9cI9x/RPjlR94Clbe/6w2UL6TvK/irl3zFD3ZbUtQKEkr9EaiO97fffX8uURfcJ1XQdwfU/96iv79Rd/7uSYj43nnxvt8QByNl3CHc+sSdFpY36FwccFHkDjCHraJzprjzF9N6KBgdL9Dz6bzbQ7l2b5bu64tu2X290cWJSbrRpRVoe1zXE/Fq6Y+LRa/aYfXXiNnd8cHqL+Dmz6A+RtFZ4H4w/R2TEPehl2jn7r3mU8491DAh5pV5IgESIAESIAESIAESCEzAbR2L2BDNSkROjgkXGbCadbZjLgBnWLxtjKV/+JaGS8nMGTOoa8icsZQqk0mIBPbuO6gT0O2yyX0hjl+rLkzg7x/uDK5m4D14NemHf27UYwhxUT+FnzumQAIkkJAJsP5IyKXDvJFABIF4F/0JngRIgARIgARIgARIgASSCgFY8yO4hX6soxMgrsR+pM9AAiRAAiRAAiRAAiRAAiRAAtERoOgfHRluJwESIAESIAESIAESIAESIAESIAESIAESIAESIAESIIFERsC/U/1EdjHMLgmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAkkZwIU/ZNz6fPaSYAESIAESIAESIAESIAESIAESIAESIAESIAESIAEkhQBiv5Jqjh5MSRAAiRAAiRAAiRAAiRAAiRAAiRAAiRAAiRAAiRAAsmZAEX/5Fz6vHYSIAESIAESIAESIAESIAESIAESIAESIAESIAESIIEkRYCif5IqTl4MCZAACZAACZAACZAACZAACZAACZAACZAACZAACZBAciZA0T85lz6vnQRIgARIgARIgARIgARIgARIgARIgARIgARIgARIIEkRoOifpIqTF0MCJEACJEACJEACJEACJEACJEACJEACJEACJEACJJCcCVD0T86lz2snARIgARIgARIgARIgARIgARIgARIgARIgARIgARJIUgQo+iep4uTFkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJJGcCFP2Tc+nz2kmABEiABEiABEiABEiABEiABEiABEiABEiABEiABJIUAYr+Sao4eTEkQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAIkQALJmQBF/+Rc+rx2EiABEiABEiABEiABEiABEiABEiABEiABEiABEiCBJEWAon+SKk5eDAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQQHImQNE/OZc+r50ESIAESIAESIAESIAESIAESIAESIAESIAESIAESCBJEUgVytXs2X80lOiMSwIkQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAIkEI8EQhL9C+bJFo9Z46lIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARCIUD3PqHQYlwSIAESIAESIAESIAESIAESIAESIAESIAESIAESIAESSMAEKPon4MJh1kiABEiABEiABEiABEiABEiABEiABEiABEiABEiABEggFAIU/UOhxbgkQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAIkkIAJUPRPwIXDrJEACZAACZAACZAACZAACZAACZAACZAACZAACZAACZBAKAQo+odCi3FJgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIIAEToOifgAuHWSMBEiABEiABEiABEiABEiABEiABEiABEiABEiABEiCBUAhQ9A+FFuOSAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQQAImQNE/ARcOs0YCJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACoRCg6B8KLcYlARIgARIgARIgARIgARIgARIgARIgARIgARIgARIggQRMgKJ/Ai4cZo0ESIAESIAESIAESIAESIAESIAESIAESIAESIAESIAEQiFA0T8UWoxLAiRAAiRAAiRAAiRAAiRAAiRAAiRAAiRAAiRAAiRAAgmYAEX/BFw4zBoJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJhEKAon8otBiXBEiABEiABEiABEiABEiABEiABEiABEiABEiABEiABBIwAYr+CbhwmDUSIAESIAESIAESIAESIAESIAESIAESIAESIAESIAESCIUARf9QaDEuCZAACZAACZAACZAACZAACZAACZAACZAACZAACZAACSRgAhT9E3DhMGskQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAIkEAoBiv6h0GJcEiABEiABEiABEiABEiABEiABEiABEiABEiABEiABEkjABFIl4LwxayRAAiRAAiRAAiRAAiRAAiRAAiRAArFE4Oy5C3LsxGk5ffa8XLp0KZZSTfrJXHPNNZIuTSrJnDGdpEmdMulfMK+QBHwQYP3hA0oQm1h/BAGJUeKEAEX/OMHKREmABEiABEiABEiABEiABEiABEgg4RCAYLfv0HHJmim9ZM+aQSBEMQRHAB0kJ06dM365rs1E4T84bIyVhAiw/oh5YbL+iDk7HhkeAbr3CY8fjyYBEiABEiABEiABEiABEiABEiCBBE8AFv4Q/DNlSEPBP8TSQgcJuIEfODKQQHIjwPoj5iXO+iPm7HhkeASumuh/6NBhT87dy56NkQvnz5+XHTt2Cn69w4ULF2XVqtVy/Phx711cTyIE1q5dL+PGTfRcjfe6Z0c8L5w4cUKWLVshe/bsDenMp0+fkRUrVtk97T2cFtc2Zsz4kNJj5MAEUEZ//DFUUF/EZ5gz529ZuHBxfJ4yRue6ePGi8dm1a/cVx6NuXrNmrbK7cMU+bDh58qTVwefOnfO5Hxs3bNgoe/fui3Y/noPVq9fIgQMHfcY5e/asHDx4KMo+lCneC95/3u8J5Pu///iOiAKPKyRAAjEmwPd0jNHxwBAJ4N24efNWe4edOXMmxKMZnQSiJwCXPhnTp44+AvcEJAB+4MhAAsmNAOuP8Euc9Uf4DJlCaASumujftu0TllOIRs8++1K0ue7c+VNp0OBWWb9+Q5Q4v/wyUG66qb506PCMVKtWW77+unui9EkI0QricXIM06fPlFOn/FtJzJ+/QL75pocHj/e6Z0c8LaDh9cYb7+g9V0defvl1adToNrn11rtUyF/pNwcQnL/88lupVKmGvPvu+3LvvQ9Kw4ZNo5Q9ru3LL7v5TYc7QyeAuuO99z4Qf8I0Ug3mfgzl7L//PlhGjRobyiFXJS5Ef/BZt2695/wQGh5++DGpX7+xtG79uFSvXkcmTpzs2Q8xAs9BrVoN5IknnrbnYfLkaZ79WFiwYKE9H48+2tbq8CeeeFbQWeYOPXv+ILVrN5DHH3/Kfp966nk5cuSoJwrK7PPPv9JnppNnGxbuvvt+SxPvBvff1q3bPPH69h0glSvfJE8//YLUrdtY8/msdVJ4InCBBEiABEIkwPd0iMAYPUYE5s//x96JDzzQUtq3f0YqVqxu70Lvju0YJc6Dkj0BfMPRpU94twH4gSMDCSQ3Aqw/wi9x1h/hM2QKoRG4KqI/RJ0sWbJYTiEuFS1axJa9/8HCe9y4Ky2fFy9eIl999a306vWtzJ49Vf788w8ZMOA3GT16nHcSCX59woS/5Lff/kjw+YyLDL744mtqwevbujcuzhcbaeK+W7p0mUyePE6mTBkv//wzR6677jp55ZWOfpP/66/J8tNPffReHSQjRgyRuXNnqGB6kzz3XPQdXn4T5M5YJ5AY78dYh6AJQlR45ZXXrV6ePXua/P33DOnY8TV56aXXPBb7vXv3kyVLlsqkSWNlzpxp2mnwljz//EtmeY88HTlyRF577U159NGH7fi5c6frqJg98vHHXbHbQsQz8bP07PmNpYG6HJ2gX3/9re1HJ9lN2rHrXT+iA+3w4SP2LK1du1zcf8WKFbVjp06doQLJF9qJ9pl25vylz9s0E/zfffeDiJPzPwmQAAmQAAkkQAKHDx+Wtm076N9j+o05W9+PU6Vv35/0r7+MH/9XAswxs5SUCGzetksGDZ8s3/YeLFNnLVJh2//V7dp7QEZOmCXdfhwkf4yYIkePnYxywKEjx2TMX7N1/x8ybMw0OX3mbJT9XCEBEkg6BC5evCSr1m6SAUMmyNYdewJeWDD1w7/L10jvX0fLD7+MkBWroxoBBzwBI5AACRiBqyL6b968RQWlCHFm06bNPkX/bdu2S6dOXeTDD9+/oqh++ulntZK+Wa04K9m+0qVLyV133SH9+/96RdzY2nD06DGZNm2GWWa7XV1s375DRad1UU6D4d/IvxNg3Tpv3gKZNWtuFMt2WIcvWrRE9u8/oB/2i+TYsctuitAxgvPBtYbbkgCW8YsW/WvCHM4L4QwCG8Lu3XvMGhfuNIIJcLmBc8ycOdvy4H3Mvn37tbHxt+Ub1w+xDevuACtqCGxopLgD8gAGOG7mzDnm0gYWxQhw1TFlynRlcUoF9OXm2sN9bEyWkY8JEyYZR4wecQKuES6gYDEMxjNmzPK4igI/HOPtVgTli3yhcYUycruF2b59p1oMt5P8+fPZKdKnTyd33nmbXus2ux7nvN6/EEhvuKGE4F5FSJkyhd6zt1uZodzcAZxg5TVp0hTZty96tyjuY+DiCvcY7gc8X+6wZMkyKx8IqijvLVu2unfb8saNmyKPvbwP8dxxwWXx4n+jHAvuSNcJuNdxP61c+Z845Y19zn0LlsjP33/Pdw7x+euvPJE28gJLcnDyNVoEFt8oW/dz6PNEutHf/YhnD+5hpuuoFDyT3iHQfu/43uvh1B9OWtExd/b7+sXzOnny1CgjTZx4w4ePsjJ9663XtXM2s6RIkUJatLjPBPTTpyNG5vTq9aNa57eRXLly2mH33XePdX4NHDjI1v/8c5TVW23atLL1rFmzyFNPtZeRI0d76qsuXT7VbU/o6JcKFidnzhzSvftXKvTXtPVXX31B3SPNldtuu9XWnX/IO+6ta6+91tl0xS/Kq3z58tK4cQPblz59eu2EeEndZ427YtTYFQdzAwmQAAkEIBDoPR3dOwzJos729U3onBLvfYycCub95RzD36RDAN84ZcuWkXbtHvNcVM2a1aVgwYJXtDc8EbhAArFAYNWaTdKjz1DJmCGdVK1QWuYvXimDR14e5el9itXrNkvXHgN18yW5uVZlHT0gJv4fP3HKoh48fFS6dh8ohw4fl9rVbpT9B4/Kl9//Luf1G56BBEggaRFYs2GL1h9DZM785fq3TI4djzq62/tqg6kfxk6aI8PHzZDiRQtI0cL5ZeDQv2TRstXeSXGdBEggAIFUAfbH6m64RmnZso0sXx7hzgaCqrO8cOEitdzvbueDQAur2w4dHvcIQu6MQFB+7LFH3Zss3tChf5rQhCEzsRkGDvxDOnf+WMqUKa3C/DHJkye35TVTpkzy66+/q8C5Skca/Ow55aefdpXixYvJO+90NNEU7jGKFLlOMmfObBa0vXr1kCpVKsmgQUNVXF6qAnBKtQLvq6LUixqnhI1a+OKLbhYHnSLXXptNz9NXMmTIYOLyww+3lttvb2rCHMRmCKnt27dVy9cRki5dOhPRu3b9RJo1u8OTJ+8F+I7v1Kmzuu2oboIwhM2ePbup9XmE4Ib8/PLLr9KkSWPrjHjzzXcEwhmuo3btm0xoxXWh8YoOnI4d35bXX3/FxEGcC+6WIKbu379fwGnVqv/UDUd96dGjm7kR6dOnn2Vp0KDBcuON5aVUqZK2HpN/EA/HjZsgNWvWsPPAUhm88ubNo50gk9Q66hcT6c+fv6D7V0mJEiX0nOXMYh8+yx2r4aJFi5hw36ZNB+2sOGoC/d9/z9PGV1ktn542FLZnz6+jZBGC988/95NbbmlsfKLsdK3cdFMNywc6TcAP3AYNGqJCaWHLpxMV9z5cnUDURtmj0wRCaL16dZwoV/yik6lduw5WNhhBM2fOXHnmmSflySfbW9wnnnhGn4+Kmt4mSZUqlflY79jxVRNtEeHLL7+R4cNHGr9u3XpIgQIF7Hrnzp0nw4aNkKFDf7N04J++Vat2MnbsCGVY3JM2rMALFMiv2yfI++9/KFWrVjGrblzLb7/9YsIx7lPct61bP6L36Ui7z8DEVwhUnj//3F/F5lwm/MIlDZ5HlHfu3LksuU6duph1ePXqVe0eRGeLv4A0fN2PEJcfeqi1nQf30r//viIfffSB57kKtN/fOZ194dQfSMMfc+cc3r949mGFjzoKz2bhwoWiREFHI57HVKlS6n0xyu7BChXKa50TIb5DkEIHpdPp6hyMewzPOQI6kbDurosrVqwg8M+P+rt48eLW4VWtWhXrWEPnTf78+bU+qqrusho7Sfr8dTrpzp07b/XmgQMHTCBp1OhmqyNx0KFDh6yzwp2A01G3du06uf76iPvXvZ/LJEACJBAMgUDvaX/vMHSkR/dNiHN/+OHHZrxRuXJFqxurVauqo5Y+CiZbjJNECOAbEX9OwDc+vhd37dotTZs2cTbzlwRincDYyXOlSgU1pLs1os1RMH9u+aRbf2lYt5rkypH1ivP9NX2B1KlRQe5uWk+OnzwlFcvdECXOrHlLJW261NKqRVPbXqVCSXmtUw9ZsHiV1KpWPkpcrpAACSRuAiWLXyf4Q1i8bE3AiwlUP5w5e07GT5knbVveIVVujDCaTJHiGhk2arpnPeBJGIEESMAIxKvonzZtWhURfzfXPBC969eva25RnnvuKXHcMiBXXbt+LTly5FBR8rErJkqFoLtt23YTwt1lmC1bVrPmhtCcI0d2966wliEQdenysfzwQw/LL87/6KPtTAxr1aplwLThcgjCbv/+vS3uyJFjVDxcaoJ+ly7v63wGh1XozySfftrZ9kNw+/TTL1T472OiGqzJIDx++umX2hh8z3O+m2+uJ/fcc5cJcg0b3mpC77hxI82C/PXX35aBAwd5xEnPQa6FKVOmqZ/stywNbH7ppdf1mD9MjIXVOFxsdOvW1UR/7P/oo8/UynuJ9O79PVbls8++kGzZssngwb+asLd69Rq5//6W6ju7tuTLl9fiQIyDOxsIi7BqQ0MX8WrUqKbi8Ntq6X6ffPJJZxOM7YAY/ENeka/+/fuYEI3GEfyQw+K9tQrMCLt27TL+hQoVNOtw+BjHvQe3UBAh77ijuS6PElgWL1++UjtO0mr8wfYL8bJp02ZmXVWy5OWPWYjh3bt/Jzt37lL/4ndp+XTxm3uU12uvvWxDtmEdjY4G8Bs06Jcox2FkwttvdzSBFffam2++Jx988JG5E3ILqO6DZs+eo0LpLeZiBdvhSx6dLug0c46BxfbEiaNNCP3mm57y3Xc/aF5aW+cCOkX69v1R/bJXsc6cN9542wTZRo0a6D33kY0CyZkzh1m7g83UqdOMNdggv3Xr1rIOqLfffk/69evt6ah7/vlX7Fnu3Pl/nuyi42vhwjlXCLJOhODKc7fdhxCtIT7Xq9dYxe/xdj0YzQF3MP36/WT38qVLl7RD5EkneZ+/0d2P//tfZ7WsQwfId8YRo0SeeeZF7dSobJ2fZMVjAABAAElEQVRIgfb7PFmIG/3VH+hwCoa5+5QYXQP/+OgQevnl523X99//5I5ilvCpU6eRBx9sZfUy7qFu3brrc3Kb1UEbN262+Khz3QHrGNGCgA6mYsWKuXd76uzduy9Pfj1+/EQbrYEOAVjhf/BBF+1E+1E7WCM+7qIkELniuATDXAKob/DMo6MVrg969+4l2bNfq/VrZa1bPreRUs5z26/fAME7aP364EZC+To3t5EACZCAv/c0OvT9fZP4q9Ph0hIjsMaO/dO+D/A+bNbsfq0bx9uIQpJPfgSaN29hnegpUqS078WyZUsnPwi84ngjsG//IRXuLxvK5Lg2q7n32XfgoE/Rf/eeA5IvT07p/FVf2bFzn2TLmkkevKexVCof0V7at/+w5Mx++VsRI0evzZZJ9up5fIWz587JqdNno4xw9xUvvrfhOzh9ujSSJnXq+D41z0cCSZZAoPrh0OFj6p3hgtYh2TwMUCcd0pH32A7jNHeYtesfGbV+gpw873+EgfuY+FjOkCqjNLu+qdTNVy0+TsdzkIBPAvEq+p8+fUbOnDltwlDjxg3NzcOyZcvNAh6jACDIwO0L/NyPGjXUI1i6cw4RD0I4fIa5g7OOD4rYDBARc+bMaSIx0oWlNAR55CGYAItyWCZDWG3Q4GYViO/0exjOB2t6x4oW13P//c1VxBwQ5TgM9UWAmAuf8rAGg8sYBFiIzVUrbQSIfIcOHfZ8QMEqGtfw9defm1ALdy+wnIXV7O7du+2YVKlSS+rUqUwAtg3678SJkyqmXe5MQfrNm9+trk8u9+RCbMPIDUf0h8U3BH8ECKtYhlV1dI0WNKTP6QcfAkYVIL1AAWmiYwEjFSZOjHB1lDVrVhOtnWNhuQ7BH6F8+XL2i/wgpEmTxqyEd+zYYeuwNK5U6Xtz7wOrKrgKAi+44HHEQ0QEf7BfvXqtdhAMkP/970PtHHrf7kv4Lsd9igAhNGPGjOYWqWfPXuaGCseiTDAyBaL+zz/3snsf8VPrByUEfAScFyM6Ro0a4xkx4ass27V7zJ4ljCIAQ4jBsELH8wb3QwgQR51nA88e8rJnz14rK1h1//BDb4tftWolG1lgB+k/jHKA2A33LXCZ0qFDe3tGn3yyvW6fbeWK65s2baaAO57hVepOCQGujDACwx3uvfduTz7glgr3FVjhgxqW2MGUJ4T44ir4I6DDDGW5bt0GW0d9gvvGGUWAdMHQcUsFgdhX+djBXv/QUfXhh//z1EPoKMKoG7h+Ql4D7fdKzsom1PvbX/2BzkN/zH09+7Cyxz195523e7J3xx1NrZPP2YC6AJb3gwYNEFj4I8Ct00MPtbaORHRGRQTvOviip2zxMeY8A5GRPXUm7sOzar2BsGvXHp3jYrCNdkKd2r790ybWu0dOOcc7v3B78NFHH8jNN9e1ER/YDtdBd9/9gHZCDrPlhx9+wFxIQTDDiAM8DyVKXK91ZSG9xzI6SfGXBEiABEIm4O89jVFo/r5J/NXpcHtXrlw5NSbYbX/IWKlSpdRQZAlF/5BLKWkc8OqrL5mFP75v27V7StsCP/ntFE8aV82ruFoE4HYH7T8npIlcPq1CvHdAM+fw0ROy4N9V0ur+plL0uvwyYeo86TNwtHR560nrADh/4by1a9zHptY2pq/0ECchCv7IF75nkTeK/qDBQAKxQyBQ/XAusr3pXSeh7sHcIJlSpY+SkYQo+COD6IRA3ij6RykursQzgctv9ng4MSyYRowYZWIZLMkh/mzduk3eeus9FZRamP/lr776xoRYZ2LUM5ET/rz/fhcTwz/7rIuJeo61p5NtuHOAgAtRLjYDfG6j0eUOaPAFG+CW5YsvPlX3I7+ZsJY3b151FfS+CZW+0sD5cueOcFPi7Meoh+3btzur9gsxM7oAsfjSpYhOCYj6H3/8uecYiGkYeYAJLeG6BuIf8uR0GCAirLkxl0KnTl1McIY1NQTaHj26WTr4+EE+kfaKFatsG/7BhzaskXwF5BeVtr/OkqeffsEEWcRFB4l7ZIOvNLEN7m/atHnCxOY6dWppB00Oj0jrHOOLlXsbeDlCJq7nySeftU6UcuXKqqgaMeG0k5bzC3c2+LvllkbWAfDII21UGL/bWLZo8YhFwzleeeVF7RxpZtbVELzff/8dJwl1d9NCxfhGKq4OVXdVEcfA+t9dFjfccL3Fx3WiQ8i7LNFBBKETzw3EbazDXZR3cF8vnhMEpyy+//5bbUgOMCtrdHSgM6dTp3es0wEdBChndIbA6hBupHr37mvW/zNnztJntqGltW3bdhOTe/b8wdadf96udZxzY3/37t9bBx+W4Z999OhhMSpPpAl3SAh7tCMDnWDu68Xz4wQI/r7Kx9nv/EIYh1Ds/Szi/nKu1d9+Jx33b0zub3/1h5OP6Jj7evZhZY96t3DhiE4w5M97ZBTuObjwcQR/xEEnJDpT0NHg+MnHqCoIXE5AhxQ6FRHgDgn73QH7ERAHdRBC06a3eO5X5KtRo4Y6iqir3ZtY9xXQ0fPAA/dG2YWORnT+LFy42Laj8+n777+xTslV6nIInX7obKtRo66nwyhKAlwhARIggSAJ+HtPp02bzu83if86fZt12rvrdLzL3PVskFlktCRCAN+1CHjnYbTs559/acJ/Erk8XkYCI5Alc0Y1+DrjydVJNR5CyJI5g2ebs6BVk+TMkUVKFC0sN5aNaKs0a1rXJv/dsHm7uQlCet5W/ac0TV/pOenylwRIIHkQCFQ/ZNX2HoJ77j7UH2gfYt4RBhIggeAJxKvojwlPb7/9VhVHHzJ3IrBKfuedTuY/3MkyJnaEwOkEiG///LNQRcdq6oc5wroX4vK8ef943Lcg7oIFC803vHNcbP1CtBw6dHgUEQqW1BBMISRBYHVXRjjvcdfEJbCih9Vxw4b1zYodrlXgXmPSpLE+s4jzwTWNO2zZsiXGQhWEYPy5w9q162TIkGE64epkjz95CJi4LgRcG4agw30RrGlhKe+IediPRiiEwWbN7lBXRw9jk4V9++C/P+ZWtMOG/e4kFfTvyJGjTYyGZZ0TvK3Lne3B/Pbq9ZNec321JO5k0cGiU6cunuXbbrvb7rtHHnnIk5wzigBlDXF09uypnn1YQIcCXB2hc8UdMEcDOhXgfsgJ6LyCyyFHHEfnCu4x+F0vXrzYFWWJ4+AO67333vK4c8JEz99//6OTpN9fjLBBeb7++sv2B0vw1q3bm8iP8m3UqIGNApg0aYpxQYdQrVo3mQU/BNaPPvrA0sd9iw6fnj2/9pwPz8Xx45efZc+OyIV3331Tn4U3o2wOtzxxn0LkhUW90zkHod8JsND3Lh9nn/sXZYNOHXRKYuQMAu6FrVu3mz/4QPvdaTnLvu7vcOqPQMx9PfvouMF1LFu2wtw5IW/oKHGH0qVLWUcSRoqgvBFQlpjIGExwv0P0Qh1csuRll1eop++5p5nFL1++rPz4Yx/rjHE6oVBHg1uJEsVtRAc6VDZu3GTxnX979+615yQ6wR/xMHIKdewLLzzjHGbXhDliMBoDAW4yMmbMYOvOyCJMII25Otx59iTABRIgARIIkoC/9/SgQUP8fpP4+yZE3ZQ5c+Yoo+0iJpBXszaGZEPgjz+GmiHG8OERbiadCy9UqJC+u5c7q/wlgVgnkDvntbJj135Purt279M2AsR93yOv8+bOYRa3ngMiFxzjJaS3dMU6NURD21EEProPHDwi2O4rwIVOQrT2RzsJeWMgARKIPQKB6ofMmdKrx4K0VicVLxJhrLZj937JlTObaRfeOYELnYRo7e+49/HOL9dJID4JxKvojwuDJXG+fPntGiH4FCtWxJadf3fddbuzaL+wDu3a9Sv1J32rZ7LXdu1am2/0UaPG2qSPs2f/bSLk1193jXJsbKzAevTixQs6cW9vPWcrc4Hy+ONPyfPPP2PiFxppffr0MyvsatWqmKXpunXrPVayPXp8b65hvvnmC89IBLiucQKEKVjROwHn69LlU+0UGaDia0vzGQ+RCwJ8bAVHhNu8eYuJ/vBLP2XKNE/yl/TrbN++fSrazbGJXCFMQ2Bs1uxO67xAxNtua2rXjcl5IQTOnDlbnn76BbXcHmVcPIlFswCXMAiOkBhNNBUd05koCVcl4Oa9njJlKpu0Ewzh6mTevAXmk7xs2TLRJel3e6pUqWxUBSzHITwOGPC758WCdfgK7979O3PvgkmPIZh+9NHnNsIE7ox8BaTZsGEDmxgZ1tNVqlQy9z6YxBVug5o0aeQ5LEOG9DbnxdNPdzBLc1jD16lT2yNgeyK6FjCCYsuWrbYF4uywYSNce/0vQgRt0KCp5q23dVg4nTvIBwIEWliCoxPh008/sm2w9Ia/9KJFixgHbISfe4jseE6eeKKtPien5bnnXtbOojx6XGdECSqEW54YefDFF900vz9pPtrZpLFjx44PeG5f9yPSwtwHsBDPqRb+sL7EPVilSkQnQKD9uFc3b95sw4LRYPAVwqk/YsIcgj6s7OFuDB1JeNZxj8F63gmYKwTC1TvvvK+dSW9qp1MqG2GSJUtmY5FGR1agPoKoX7lyBesE6d27n3VstWz5oCXzwAP3GbvPP//KxHm4q0Bd2KLFfSb4I9J7772tE4C/Yx1MqPcWL16i84r8rh2J/uu6cuXKmiUt6s4HH7zfOokxjwPckzmTHMKvNkaQfffdNzYCACN43nzzXZ2T4SlPR6dzvfwlARIggVAI+HtPB3qH+fsmbNKksbpw6WDu6DCRKwwxMDIN8wFhxCBD8iCAb47OnT+xtkCHDu3s+wMuFPEt8/jjbZIHBF7lVSFwU9Xy0vf3sQJL/fx5c8nE6fOlTMmiki1LxDfijLn/qsh/Rm5tUNPy16B2FenVf7hs3rZLChfIK5NnLNBRwinV1U8B21+tUhkZPnaGTJ+7SOpUr2Duf9KkSS0VypbweX1wn0MXOj7RcCMJJHgCJ3WUENzuIKB9efDQMTmofvlTp04pmbXNhuUJU/6W+rUrS4G8OSVQ/YC2c80q5WTq7EU2mujs2fPy9z/LpUEd33oL3OfQhU6Cv02YwatEIN5F/23btqvFclG7XDRoihYtYsuh/MMH8SefdLYP4tdff8sEq7feesPjdiKUtALFhWXwjz9+pwLVBypy97XocEV0221NbBmjF+B2pXXrdipIpzdxHMIWrGkRnnvuaRWf/ie1azcwURRuJz7//GPbh39w+fLKK2/oKIWqalHd00YFwN1Kp05dbPJMxEdHSIcOj3uOCXcBFuOwVMcEpxD+4BLmoYceMKEPaeN6YCmNyYshBkKYh5Xu008/b6J+0aJF1AXO42bNhlEbEMgh+Hbt+nFQgj/OAa6NGzfS8z4qmMTzl1/6YPMVAUPhIbzCDc6sWVN10tao6/BHPn78BOXb0O4lTJjboMHNV6QT7Ab4BkfnRc2a9W10A6yJkVcnfPDBu+b25rXX3jRrY2xHZ0/fvj/5dS2FiX4//bSrdha9YvNagG+RIkVsklhn/gakdeutTUwwr1evkU1QWqlSBXV3EjHSAPt9hY4dX7M5BYYNG64uWLKruPmazRfgK673NrgNgLX+s8++ZB0qcMly++1NjbMTt1GjBjY5bq1aNWwTOnrefvt/Ks42cKLYiIX+/X+SN954R93//KzXeFbTqKui7queOMEshFueELRRN3Tu/LF1SsFSvWvXTz1uX6LLg6/7ERzh2ur22++x57lIkcLaqfGtdS4hnUD7IZ6DK56zvn1/9HnqcOoPdMaFyhwdfugcRZ3TqNFtKuin0DrqGZtvwMkgRP3u3b9S91qf6OiOW60uKFmyhD2jOXPmsGjPPPOkWc0/8kgbK2t0/GESZ0xSjYAOgl9++dnOA9dRqB8wCuCNN16x/fh3662NrdPr/fc7m7iVKVNGdWFwn7z44rOeOL4W4GoKE6NDFPnii272YYly7979a+uUwDH339/c6q2XXnrNnlN0Zt166y1aHk/6SpLbSIAESCBoAv7e04HeYf6+CWEQ8MknXdQNYGczBsGov8cea2UGF0FnjhETPQG8z/COw1xRTZrcae84vFMff7wN32GJvnQT9gVULHeDNKq3W7r9OFjOn7ug4n0+eaLV3Z5Mr1y7Ub/9TnpE/9I3FJG7m9aTH/uPlGM6Mh+dA8+0vVeyZo4w7MJv+0ebycBhE2XwiCnq5z+zPN3mHv0mjHf5wXMNXCABEogbAmMmzZapMxd5Eh84dKItlylVRF5o30KO6zx+M/9eop1+15voH0z90KxpHTmg3ije7tLLRgtVr1xGGtWt6jkHF0iABIIjcI32xAU1bnj7nsNSME+24FKNx1iwSM+ZM6fHGjsuTw3xG8KUYynvPhdcYcC61Ns/thMH+0+fPmVuMZxt7l9MMOoMh3S243wQ3f25unDixuQXeTp//pzH8tZJ4+WX3zDreUwY5gS4gUHHRadO70WZUA63z6FDh83ftxM3lF90jqAnF3/+Atg61tiI570OVrC+g7gYGwHiN+aHiC5fuG5Y+SMOOmZCCfv27ddyzawie/THndKRDWDjvmZ/58D9A6v9cOa02L//gE08jJEJ4QSUDawd/V1foPTDLU+UD64Hz2Moz4+v+xFs4WbMbQ3vzr+//dgH4SZ9ev++B8OtP2LCHPc46jOI/NEF5OuCTsQW3X0I11Uoq+jqPaSL84Cdv2cTLi/8pRFd/vCcYFJgdIBEF/C8OZ0R0cXhdhIgARIIlYC/93Sgd1igb0K4XMycOcsV34Wh5pHxEzcBuOTDveJ0uCfuq2HuEwqBQG16fAufPnNOMqhrjWADrHz9xT9+8pRkihxFHGyaCT1eII4JPf/MHwnEhEBc3PeB6ge4BkuRQueHDFOjiMn1xtUxccExrvLKdBM/gUQv+if+Ikh4VwAXObBIL1eujMAdCMS6+fP/UXE7jVo69wgoYCa8K2KOSIAESIAESIAESIAESIAESCB5E6DYFDvlT46xw5GpJC4CvO9jp7zIMXY4MpXgCIRn0hvcORgrkRGA+6QFC2YJXDGtXr3G3MzAnVGpUiUT2ZUwuyRAAiRAAiRAAiRAAiRAAiRAAiCAUcwYERvdaGZSCkyA/AIzYoykSYD1R/jlyvojfIZMITQCFP1D45VsYqNCh79//DGQAAmQAAmQAAmQAAmQAAmQAAkkbgLp0qSSE6fUvWuG6N07Ju4rjPvcgx84MpBAciPA+iP8Emf9ET5DphAagRShRWdsEiABEiABEiABEiABEiABEiABEiCBxEYgc8Z0cuT4KTl+8qxZ/Ce2/F/N/MJCF9zADxwZSCC5EWD9EfMSZ/0Rc3Y8MjwC9OkfHj8eTQIkQAIkQAIkQAIkQAIkQAIkQAKJgsDZcxfk2InTcvrseQr/IZQYRsLD0hnCZ5rUKUM4klFJIOkQYP0Rs7Jk/REzbjwqfAIclxY+Q6ZAAiRAAiRAAiRAAiRAAiRAAiRAAgmeAATrHNkyJvh8MoMkQAIJjwDrj4RXJswRCfgjQPc+/uhwHwmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAkkIgIU/RNRYTGrJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJOCPAEV/f3S4jwRIgARIgARIgARIgARIgARIgARIgARIgARIgARIgAQSEQGK/omosJhVEiABEiABEiABEiABEiABEiABEiABEiABEiABEiABEvBHgKK/PzrcRwIkQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAKJiABF/0RUWMwqCZAACZAACZAACZAACZAACZAACZAACZAACZAACZAACfgjQNHfHx3uIwESIAESIAESIAESIAESIAESIAESIAESIAESIAESIIFERICifyIqLGaVBEiABEiABEiABEiABEiABEiABEiABEiABEiABEiABPwRoOjvjw73kQAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkEAiIkDRPxEVFrNKAiRAAiRAAiRAAiRAAiRAAiRAAiRAAiRAAiRAAiRAAv4IUPT3R4f7SIAESIAESIAESIAESIAESIAESIAESIAESIAESIAESCAREaDon4gKi1klARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgAX8EKPr7o8N9JEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJJCICFD0T0SFxaySAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQgD8CFP390eE+EiABEiABEiABEiABEiABEiABEiABEiABEiABEiABEkhEBCj6J6LCYlZJgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIwB+BVP52eu/bvuew9yaukwAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJJBACIYn+BfNkSyDZZjZIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgAS8CdC9jzcRrpMACZAACZAACZAACZAACZAACZAACZAACZAACZAACZBAIiVA0T+RFhyzTQIkQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAIkQALeBCj6exPhOgmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAkkUgIU/RNpwTHbJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJOBNgKK/NxGukwAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkEAiJUDRP5EWHLNNAiRAAiRAAiRAAiRAAiRAAiRAAiRAAiRAAiRAAiRAAt4EKPp7E+E6CZAACZAACZAACZAACZAACZAACZAACZAACZAACZAACSRSAhT9E2nBMdskQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAIk4E2Aor83Ea6TAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQQCIlQNE/kRYcs00CJEACJEACJEACJEACJEACJEACJEACJEACJEACJEAC3gQo+nsT4ToJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJJFICFP0TacEx2yRAAiRAAiRAAiRAAiRAAiRAAiRAAiRAAiRAAiRAAiTgTYCivzcRrpMACZAACZAACZAACZAACZAACZAACZAACZAACZAACZBAIiVA0T+RFhyzTQIkQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAIkQALeBCj6exPhOgmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAkkUgIU/RNpwTHbJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJOBNgKK/NxGukwAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkEAiJZAqkeab2SYBEiABEiABEiABEiABEiABEiABEgiBwNlzF+TYidNy+ux5uXTpUghHJu+o11xzjaRLk0oyZ0wnaVKnTN4wePXJlgDrj5gVPeuPmHHjUeEToOgfPkOmQAIkQAIkQAIkQAIkQAIkQAIkQAIJmgAEu32HjkvWTOkle9YMAiGKITgC6CA5ceqc8ct1bSYK/8FhY6wkRID1R8wLk/VHzNnxyPAI0L1PePx4NAmQAAmQAAmQAAmQAAmQAAmQAAkkeAKw8IfgnylDGgr+IZYWOkjADfzAkYEEkhsB1h8xL3HWHzFnxyPDI3DVRP9Dhw57cu5edjaeP39eVq1aLZs3b5ULFy46m6P8njp1yuJcuHAhynauJD0CKOMdO3bKyZMn7X7YtWu34B4JN7jTDTetmB6/Z89ewb18NYPzvO3evedqZiPJnHv58hUyadKUeL+eOXP+loULF8f7eYM94f79B2T9+g1+o+N94H0f4rnH8++u64O5Zzdv3nJFWu6TI73//lstx48fd2+Osoxz41107ty5KNu5QgIkkPwIrF27XsaMGZ/8LpxXHO8EYBGINhDeUWfOnIn38/OESZcAXPpkTJ866V5gPFwZ+IEjAwkkNwKsP8IvcdYf4TNkCqERuGqif9u2T1hOIag8++xLUXLdr9+vUqlSTXn66efl3nsflOrVa8uIEaM9cSDUvPrqm1K1am15/vmXpWbNevL551959iemBQhZy5atSExZjrW8Tp8+U8XuwFYSEDLr1GkoTz31vMyePVd27twp9evfIuvWrQ8rL97phpVYkAf7Ku8777z3qooIX375jVSuXFMefriV1KvXWG6//R7ZunVbkFfEaL4ITJo0VX74oY+vXVG2BfsMRDnIz8rvvw+WUaPG+olxdXbt27dPmjdvIQ0b3iqPP/6U3HxzE5/3PJ7xO+9sLu+8874noz/80Fuf9yZa17/iEfAD3bP//LNIatduIA8++Kjcddd9cvfdDwjEOnfo23eA3vc36XvmBalbt7E88cSz1qnoxIHg8sYb70itWg1039NSrVodmTx5mrObvyRAAsmQwPz5C+TLL7slwyvnJccngfnz/7F32AMPtJT27Z+RihWrWzsnNoxd4vM6eK6ESQDfN3TpE17ZgB84MpBAciPA+iP8Emf9ET5DphAagavi0//IkaOSJUsWyymsWIoWLWLL+DdlynT56qtu0rv391KjRjXb3rPnD9Kx4zty0001JE+e3PbhO2/efBk3boRcd11h2bJlqzz0UCtbfvDB+z1pJYaFCRP+UvF6g9x4Y7nEkN1YzeOLL75mZVigQH6/6Q4fPkrF6Lry2WddLN7Zs2dl0KABUqTIdX6PC7TTO91A8WNjv6/y7tOnl+TPny82kg85jYEDB0mfPv3km2++UCG2nmAExcsvvyGvvNJRhg79LeT0eEBoBIJ9BkJLNeHF7tDhWcmYMaPMnz9b0qdPp+L5VOu4vf76YlKqVEnLMOrxqVOny7RpE8VdJ/z66+/y1luvawfw3RYv0D2LDob27Z+WRx99WF577SW5ePGSiXTPPfeSDB/+h+Vj6tQZ+h75Qrp37yaNGzewkTYQVt599wN9/3xm5+ndu58sWbJUR2yMlVy5csqwYSO04+Elzfv4KPlLeLSZIxIgARIggcRK4PDhw9K2bQf9FntBO5zb2mXMm7dAtz0hpUuX0o7s2xPrpTHfiYDA5m27ZN7ClbL3wEEpV7K4NKhTRTsIos/4gn9XydIV69XP/Sm5rmBeadqwpqRPl9ZzwKEjx2TO/KWyfvMOKZQ/t9xxS21JlzaNZz8XSIAEkg4BtLlWr98si5aukfq1KknhAnn8Xlww9cO/y9doemvlwsULUrt6eSlXqrjfNLmTBEjgSgJXxdIfLheKFi1qudm0aXMU0X/9+vVqEXqPR/BHpPvvb2696Y6lJqxj7733HhP5sR/Cf5s2reTrr7/FapyEo0ePqRg1w6zy3S4mtm/foRak66KcE/nctm27Z9uJEycEH+yzZs2NYtm+YsVKWbRoicDlBSxTjx277GICHSM435o1a6NYEsAyftGif821Dc7711+T5ciRI3YuuMSYOHGybNiw0XNufwt79+6zc8ycOdvy4B133779Amt45BvXDzdLWHeH9eqqAwIaGinugDyAAY6bOXOOrFixSsW3CDdNBw8ess4duLRZunS5rF69xn2oZxkuN3CtsDo/fTriuuH6w+kdveaaiNsX50I5IA8TJkwSxHEC2OP6Vq78z3P+6NJF/nA+dzngeGxzXEwtWbLMzgOLfZQPhErvgB5wXBM6sMDQCf7KO0WKy48ijsdwbtznuA/cwR9XdzxnGR0kzv3ibEP62Ab+uC/xLN1ySyNJnTq1FC5cSFq2fFDLa6Uy9z+cHBxxPO5BPNPuEAynjRs3RR57mSF4upniWVu8+F930uYeBvyd4KuMsc95VlB2yM/ff893DvH5i3sZ9w+eRYxAcgKeE9w/yMuCBQtVuP4nynOMeGDquPTxLjMnHfevv2fAX/k754ru/nCfI7rlcOosJ00I67B6d9dzzj7vXzwD4Pfkk0+Y4I/9jRs3lCpVKsn33/9k0VGX4V5C2LBhk9UXO3fusvsUzzPO59zHge7ZBQsWydmzZ+S5556yuiJlyhTawfCS7NmzR0eMjbFz4NkqX768Cf7YkD59eusgGDNmnMf9UK9eP+qohDYm+CPOfffhnXOdoNPBHaK7b9xxuEwCJJC0COB7Ae8CuHFD/eQd/NULeGehHvP+JnTSCKV+dY7hb9IhgPdl2bJlpF27xzwXVbNmdSlYsOAV7Q1PBC6QQCwQWLVmk/ToM1QyZkgnVSuUlvmLV8rgkZOjTXn8lHkyasIsqVS+hNylYv7Bw0fls+6/ahs1wu0u1rt2HyiHDh+X2tVulP0Hj8qX3/8u5/V7moEESCBpEVizYYvWH0O0k2+5/i2TY8dP+L3AYOqHsZPmyPBxM6R40QJStHB+GTj0L1m0bLXfdLmTBEjgSgLxaukPn5QtW7YxcQxZgbAIoQxh4cJF0qtXdxWG2tu68w/iG1w55M2bRzsCqtpmR/h14uA3X758AiENAnrOnDncu8JeHjjwD+nc+WMpU6a0CsLHbLQB8popUyaBFerKlatkwICfPef59NOuUrx4MXVR0dEEzNatHzer9MyZM6sF9et6nT1M8Bo0aKiK3kslZcqU8tNPfVV0elEyZy6haf0mX3zRzeKgU+Taa7PpefpKhgwZVGTbpm5YWqsLlqbm4xrrEDXbt28rf/45QtKlS2eCc9eun0izZnd48uS9AJ+0nTp1VtdJ1U3EhojYs2c3dWVR06IiP7/88qs0adLYRPA333zHhDFY19eufZOJnrguNF7RgdOx49vy+uuvSIsW99nxX3/dPbI89hunVav+kwYN6kuPHt3MLQ+syxEGDRqsoxzKe6x9bWPkv507d5uLlK1bt1qjGu5SOnRop8JbIWMwceJo6zDCuVKlSmViLQ7t3v1LZVZJxo6dIO+//6G6gapigh98cv/22y/mIgRpeadbpkwpSxesq1ePuNfQgQPeCxfO1dEpmdXq6hl1PVVRNm3aZOeECN+x46smDuLc6IB5+OHH7HxotOHe6Ny5k5bXrXqtvsv72WdfNHYoL3RcPPRQa+ugwD3/77+vyEcffeApS39cIW56B3B56aXX5MMP/2f8sf/ff5foc/aszJ07XVld6RYLec6RI7veS5ctdXCcO4BLu3Yd7L7GqJ05c+bKM8886Xl+A3HCMz18+Eh1zVVDunXroZbTBfQZ6Kl5mmcW1c4oA/inb9WqnZblCClRIqJnH2l37PiaWVtHV8YoK+dZad36EX02Rtq9fdNNNdyX4Vnu0uVTHXUywfKDexVD6HEfoAwmTpwkP//cX8XfXFYucCuFEUfYnzt3LvO1+9BDrVQs3midlbi2ggULeNL2tYA0fD0Dgco/0H5f5/LeFk6dhbQ+/PBj61ysXLmi1eHVqlVVq/mPvE/jWXc64VKkiGoqhjp70aKI+QdGjx6vz+9CO+bnn/uZuF6tWhVzVYSywAgZdJB+8cUnAe/ZQ4cOaZ2aKkpnKZ6N3LlzewQTxHF3tOHEzmibtWvXSdasWazeq1y5kuc6sIBnH/eHE/zdN04c/pIACSQtAufOnTM3ZegIxjcajBvwLq1Xr45dqL96AZ3a0X0T4uBQ69ekRZZXAwL4xsafE/CNP2jQEBuJ2bRpE2czf0kg1gmMnTxXqlTQ0SS3RtRlBdUy/5Nu/aVh3WqSK0fWK86378Ah/V7KJFUrlrZ9+w4ekSXL16lF7kVJJSll1rylkjZdamnVoqntr1KhpLzWqYcsWLxKalUrf0V63EACJJB4CZQsfp3gD2HxMt8Gne6rC1Q/nDl7TtCx2LblHVLlxlJ2KNqSw0ZN96y70+MyCZBA9ATiVfRPmzatCnq/q/uEb03Qrl+/rrkRgUVmsWIRlv9OViEqwh0DhDsI6KNHD5M0aSKGA0LEHT9+ogmtEGdgsTxyZITPf1hX5cwZe6I/BKAuXT5W8bmH+pWua2Lgo4+2U8FylIqRLZ3sRvs7evQ4G4nQv39vizNy5BgVXZfa9Xfp8r7OZ3BYhf5M8umn/2fvTOB0qv4//s2+jXWUbJHsZC+y7/uaJCHZij+VJWQJoazZIxEiSaSIyL7vS5IklfWHhsjOUP/z+Y573XnmWWdhhs95vWae+9x77jnnvs+557n3u51BehyW/UOHjjSC/2km3nQRFTJCCDx06CjzMtjPrgehWBo0qKsvm4iTDaHr0qXfGmFXPCNA7q3WqN6E/qtWrTGhLN7RMlDoW2+9bc75UgWjsOCG18SYMSNU6I/jQ4YMMxbXezXsEr4PGzZSUqdOLfPmzVZrWli2N27czMTGLm0UMBmQRc6dO2eErXNV6A+rNrzoIh/CNvXv31tjbX/wwSCPoTJy5XpKpkyZoPFMs2TJZM7po+WGuLGqg/Dwyy9n2cJWWIL37t1PZsyYagR1hfQ8xAQfMWK0EcK/67Zcp3W3nuDhHwTKUDhAaDh27ET56KOPjdt1S/3+7ruD1DL4q68+1zAi69ZtMKFJ+kn16lXMOIrY365V4PzMmSEA/0i54vyOHd80iouitlDSE9f8+cMeup1loo1169ZWBQiULkhQ+FSvXs2+n6z8oaGhRvHzsSqy3n//PWu328+NGzeZMqpKv37v6HHEkodCon37Ntpu7PTECYKS6dM/M39TTJz0YqpA6tGjtypjKleuaMb5EFt5B4tsKB9Wr16jQn94B8DyvmzZ51Tp5a2PrYZD2bZz56YIQl7rOMY7xvbMmdO0Drxgly9fRb0QWrZ8WbOdMmGPpk6dpHPRpUuXde2DJUu+136Hguz48ROybt0KSZs2jSpuatVqYPrLc9gqT/eAr/73ddy6pqh8epuzli5drqF5liz5Wu9/sKtXr7GOqTp1arqtFsoazNMLFnyjyjR4lMB7Z/PmLabPwxbk7tbtDfWiatz4JTOORqiiE4WhzKefLq5eAjVqVI1QvrsxCw8CeLhA0dO8+Ut6Drxy4AmF3wekYsWKygcfDFdPqty5c+m+GTNmCX6joLxJly7sNyR16vAvufiOkD9I/owbzch/JEACDxQB/Ab17t1TlflQSvbq1U8GDhxi5salagjh7fckuufXBwosLyYCAayFg+eeePHiG8H/Z8YDIOJzXoSTuIMEIkkg5Ox5KVwgp312ujSpjAGFSIgJ9eNO6F+lfAkZN2WeDB0/S5B3/8HfjcKgtCROlFDLCDl7QYLT3n2OwjtJmtQp5C9Tj7v03dLdMvXTtebd9pq7wzG27+v5b3otGx7mSZMkkkTm+ZWJBEggegj4mh/OX7ikXkPBaVPbFWKeOW+iIMCbKEGC+PZ+bGw4tUMWHV4mV2959zAId9I9+JIsQXKp91QNKft4WNjye1AlqyCBCAQimgZHyBJ9OxAuBJbQEJqkSZNGt/ft+8kIvYPUWtZZU8aMGTSOc69ePdSSvVWrdirgRp4+fXpo1tKlK5qwPu1MiIbaai2OnbC+j86EUB/BwcEq8Ee5sJyGQL5JkzCLdl91IVY/QttAyIn1C+rXr2OE2K08nob6YE1vWZjiAalx44bqCeE8Ca6+SBCsIuQErG0tS29Y4CKEBxIUIgiTASE4/qxFwEaPHq4CVwjD5s9fKKGht1QAh3MSJEhoQr0kUGEsviNduXLVCDTThn0x/zcbi2zU88svvxrL14NGOfGfCjwtzw1khHLG6g8IObHtbfFdvEhb7YTXRiCpVKmStsAf50GxkipVKhXioX34QyxUWLlHNZUtW9oWICNMCYTAZ878pcVirYk6dWqpwB87oChCTHD0oz8JypHGjRvZgnOcD08PhEGykjeu7hhizCGGOu4/CLRhNY19zgTheu3aDeWrr75Wjw+MOSRP46d161fkjTc6argnKMDQb7BCd4YE8sQJQl/EcccCrQhvYILjqJUkrOphOZ8/f34jQN+g9aNd7du31VBJ2LFu3UZVGiE+vL99jFjwFn/MP9b9gE8kjEsop27dClUL9gULFurYgZDYSpmNIiZHjif1a1BQCm0D1uJA2rdvv1GWldLxj+9QhpUu/Rw2NYG5VSc4wTvGU/LV/76OO8sNpF7ned7mLIRIKlCggLme03pPHTt2wvTl3fvK3XjByxIE+atWrdYFuV95pa16w1SrVsUodJLqnOqs399tT2MW9zliIcNitnr1umYx3xa6DgxCWFnz0UsvvSAVKpRXhUXTpi2lRo16OmfCiyhFiuT2PImx6UwI6WGNJX/GjfNcbpMACTwYBPAbVr16Vb0YPBPC8xKK37Nnwzwbvf2eRGV+fTDo8SoCIdCt21tqoANFdevWr+vvbiDnMy8JBEIAYXfw/melRHe2r1+/ae0K93nt2nWJZ0KtXr16zYTwuSj/mSiuV67esPPcun1LQ4faO8xGQvOO6am8+yHwd7bN0zbCbl7zwMDTOdxPAiTgnYCv+SHUGFUguc5JUERevxFxToqNAn+0H0oItI2JBO4ngbu/7PegFRA8fvPNIo1lCktyCE9g8QlL6KZNm9jxldEUCFQsy+QmTRoZoVpFtV7v0KGdWoYvWrTACNt+0vMLFSpohKTx1OI6R47wHgNRvSwIzyHUcia88Pmb4O49cuRQYz09R63nM2TIYCzN+6vQ0F0ZqA+CT2eC1emJEyecu2yhcLidd77gJfQ/PHmZBKH+++8P120I3xCGCGsgYMHKLVu2qoAabbIUBsgIy+r33usvAwYMNuE1vlOhNoSlEyaM0XLw8IN2omwoNKyEGNmwRnKXUDcmbQjNPKUOHd7QsDjIW7FihXCeDZ7Osfa79glewGG5D8t1Z8qVK6fza6S20T4rWd4nuC7Ud/78BTNewiyHrTwQUPuTcD4E5679HxycTgUK7spw5eqOISyZs2TJLBCSwuIabS5RophdHLwfYOXcrl1rY1HdRsM4WQfdjR8opebNW2A8dsaqsAPfEaLKNXnihHyTJo3TOgcOHKwu6w0b1jfjrY8KgKtUqaRjCyGWYE2N0FVTp05X6//16zdoPHiU4W8fW32Ec8aPn6RKD2xD8QgPIoRmaNWqnSqIypR5Tj2FnG1HXtfvKBMeC0iIFY+Fpp0JFv8I+4CE402ahHkMoJyuXd8065bU02POf77639dxZ1nY9rde1/O8zVnHjx9XBY/zvsI1IfQRkqfxAq5r165Qj4pLly6pR9GKFasieHi5tsXTd29jFufgd6J27Rq6lgMWDi5TprQuBm/9PsCif9KksXeUlr/o/QFF6rPPllXlDhRQSFA+WteG77i/EdoJyZ9xoxn5jwRI4IEiAMWu85kJXolImBMSJ07i9fckKvPrAwWRF+MXAfx2Ir3wQiP1lh0+fJR5dvrEr3OZiQQCJZAyKLkx9rkrtL96Z22vlEHJIhQFwdvU2Yslf54npXnj6nociwAPGzdLcj6ZSRfbRHmuVv3XTJnuyotQAXeQAAk80AR8zQ+pjJEdEpSLVsL8Afkh1h1hIgES8J/APRX61zGhGmrVqm4WRGyqoT1gldynzwCN5W01uUePPipMGzVqqLVLhZCIMY6wJkiIr122bBkVnMOCHGnKlDBhNhZkjM4EITEs4Z0WnrDWxXcIUiHsdE5GqPuyY+GSc8YlslSpZ6VSpfLGmj5Uw8H07TtArb/dtRP1/WAWRnWmo0eP2lbGzv3+bMMCDX/OdOjQb8aie4FZ4HalxizHMQibcV1IuDa4oCN8UYUKZTXeuiXownEI+fCSi/BBVvgM7A8JgZWbfwJu5HdNCP0UXQkcoYCYOHG0XST66fLlS/Z31w1LYYFFg63k7Etrn6dPrLmQKVNGI9j80SwSWkCzgeXevT+qJwqUMd6SdT4UYfCiQML5x46dkKeeyuHtVPuYJ4b169fVmPXwqkG4H0uIDUXAJ598quGE4FXgmtyNH+SB0BWhfTAGkLDI6qRJU3Tb178bN25o/W+/3cWEouqiC0+3bNlWQ7+gvMqVK6oXAITCsMaGEgqW9Ii5v3Pnbl3jAHVEpo/79u1lFF69wjXx228Xq3IB1plWQl3+pscee0zX5nDmP3PH8wP7ECt+48bVzsNut331v6/jroV6qjcqcxYUSBhDzrUgwhYuDrOIdzdeQkJC7FA7lStXsJu5Zs16XSfF3uHnhq8xC6+YAybu/ksvNdGFqVEshHEIAVatWhWtBWGKkidPpp44VriEvWax54sXLwquEUobCPa2bt2h362m7dix04REC1PYRHXcWGXykwRIIG4RwJogN2/etEPkwQgC82rWrFk09jqU1Z5+T7w9E/qaX+MWJbY2sgS+/HK+GkUsXDhPn3+scrJkyaLGTtZ3fpJAdBN4NDiNnDx11i721OkQ87wuEpwujb3P2rho3nURfqNg3jAvWOzPluVxCUqRTI4eP6NCf5T34/7fNEQQykGM7nMm7j/2u0ttW1e4L+F93LXFuQ/vTAjvw0QCJBB9BHzND0EpkhoZYGKdk3Jky6wVnzx9VtIHp7blGM7WIIRObLT2t8L7ONvKbRK41wS8SyFjoDWIjf344xm1ZMSpfPLJbOFqwUKyiO+NOOx169bSmF2zzWK5eKmCBTASQsogpMioUcOM1XoWI7zeaIS7kzXufrjCouELlAr//nvbLL471cTvbqHhS9q0eV06d+6oQn+8pE2bNkMXkYX1NISSCGED7wOkCRMmaSzpsWNH6gsiQrU4FRMQPMGK3kqob/DgoUYpMstY9TTTsCBQckAAH13Jsso+cuSoCv0RemTVqjV28bDkh6BuypRNGocb1uEQsNarV0eVF8hYs2YNvW54Y0DQjT7oYCz1ly1bpFzswjxsWNbvEBji/OhOiIEP63/0W7t2r5p+u27WiOhirHQfs9dPcK0TwmV4QSDETZEihfVBd/HiJa7ZvH6HUBEKlaJFC6ngH7HuZ82ao1xwomt/uxaGMY41AmB1HBycTj0VMF6KFQtTArjm9/c77qXx4z8ylvSICzvbPm3Tpi3qWYAQUQg/5UyZM2f0GHoFXhtHj4blhzIF8dr9TRCsVqxYwywUPVXDWFkKpWTJwhR2OXPm0IWEoUQYOnSIFlulSkWNwZ49ezZ7bYPI9LG7NmLRVwhxcB8iJBRC6CD2e36zELM/CbHmBwwYZPp4hVStWknWrt2gYaScFuLuynF3D/jqf1/HkyRJYvrxiC5iayl2XOuOypyF8Y0FnDFusNAgFIXwYujevYtb7wXUnTZtOhWEIRxSz55dzZhKaBbU/tLM4794vBdd2+z87mvMog8HDhyi93zTpi8Yj4cQ81sxRhVntWqFWaMhxBI8zD76aKwqj+Gx1KtXX7N+xuu2IhRz7pQpWFulkJ47deoMVTw3a/aiNieq48Z5TdwmARKIOwTwW4W1qTp0aK8GE/AggzcRnjl8zQvengkjM7/GHWpsqb8E8Pw3aNAH+i7Qvn1rfRaEknyJWUeoTZtW/hbDfCQQMIFSxQvK9C+WyO9HTkjGDOll+dptki93dkmdMszidt3mPSasxg2pXrGkpDJW/MFmcd91W/ZItqwZ1fJ2266f5eKlq/LkE2HvdSWK5JOFS9bJ2s27pMwzhWTZ6q3mXTihFMrv3uu6Tq2igj8mEiCBuEfgqvESssLuQJb09/lL8rdRDCZMGF+CjLwL28tWbZHypYtKpgzB4mt+wHtsyWIFZPXGXfJ0/qeMscUt2bLjJ6lY5m60AiclxMxn3HwnEW6TwF0C91zof/z4CWO1nl1bAIFR9uzZdNv6h8VpET9+8uQp+tCLSQPhQz78cLgKQpFv4MC+Rsg2RD0GEGIjZ86n1HrXinNvlRUdn7CWnTLlI2PVPNAIuadrkQhFVLNmNd2G9wLi8Lds2VrjU0M43qTJ82qhjQydOnUwwqV3jYCsor4QIqzE8OHv67n4h3jjXbv20MUqP/54onoFIPTJgAGDzUK64zXkCAS27du3sc+J6gZik7/8clMjvHtNLdPAF8KxuXO/0qJxPfBKwOLFiF8Owfz27TvNC25nFV5nz55Nw8DAmg1eG+gDvOyOGPG+XwJ/VAKuVapUNvU2l8KFCxkB8DTsjrYERcXMmZ8YBVIfExrmU7NmxE0NwdKzZzevdQwbNsRYn79jxlo5o5xJYjxRetmLRHs98c7BHj26ybvvvievvNJOBebp0wcb746R9qnu+ts+aDZ69equ4ZRq1WqgYyhbtqzmXhinwmhnvkC3IViHIg3hSSBUtxL6Fh431aqFWexb+/H5ww/f6b3n3Gdt9+zZXa8T8e+x1gPaPX/+19Zhr58Qhg8ZMtAsYv2WuWeSaAgVWIgj7IGVKleuqILh5557VndBudS797vGs6SilUVDFUWmj+0C7mzUrl3DLAy+zNyjlXQ+wiLZFStWcM3m8Xv9+nXVshz3Me4DeAAhpjyUld6Su3vAV//7Oo75E1xxb2OhZHcpKnMWFsn94IPBZlHtQaokgbXrK6+0UIWgu7qwD2EwEI6gZ8++po+rGkYJVKkGbwEotgJN/ozZTz6ZZNr4nsbyh6INArmRI4eqSyjqa9y4oc5rb73VXT2zcH9Ur17VsHvNbk7Hjq+p5f/LL7fS+QPKSSwMjnsaKarjxq6IGyRAAnGKQPXq1VSpWK5cZV0nB7+tw4YN1mvwNS94eyaMzPwap8CxsX4RgPHJzJlT9RmrWrU6qsRPmTJIBf7O3yi/CmMmEgiAQOECuaRyudMyxizOeyv0tmR/4nFp16K+XcLPh/4wz0VXVeiPnR1bPy+fzfteeg+epN5OsIZv0qCy5M2VTc+BYqBt83ry+YLlMu+bVZI6VZB0aNVAnwM1A/+RAAk8MAS+W7FRVq/fZV/P5/OX63a+PNnkjbZN5LKR763fstco/Z5Sob8/80O9GmXknIlG0XvwZDXGfKZoPqlctrhdBzdIgAT8I/CIEaqHxWXwkf/EmQuS+bHUPnJF7+GzZ8+p0BuCZ3cJi9JiEVVYz9+LBGFTihTJ9cHGtT4sYArrUYQhcpdw/Pr1axoywt1xLLrpjBGLPKgP124tHOnuvKjsQ5uweGmKFOH5dunSQy2fnXFDEZIFiosBA/qZdQBq2tVi+ECQjHAYkUkIXwNNLv5iKqFfYH0HS35/E8YeXrISJYqcOyf6E6GEYHXsLrnrb2c+HEcMd09j35n3fm2jjbDaj8r9B86pU6fy6FHg77VFpo9dy8b9BgtOCO4jk6AoQxgZT3OApzLd3QO++t/bcRyDMB5KK28pqnMWQoIFBaWMMG95qxNjGgmhiu5FwtyE+9jybnJXZ0iIcRW9I8h3dxy/Mxgbnvo1quPGXZ3cRwIkEPsJXLt2TZXzlteWs8W+5gVfz4SRmV+d9XP7wSAA4xqMlcgoyB8MAryKmCDg650ez6XXb4RKMhNaw5+EBYBvmPze4mxfNov9prjj0etPmXEhjy+OceEa2EYSCJRATIx7X/MDQoPFi2fWh0xwz+2VA8Xjd/6Y4Oh35cz40BGI1UL/h643YskFI7xJ585dpUCBfJI3bx4Vgm7btsMoYBIZq/MJPoWJseQy2AwSIAESIAESIAESIAESIAESIIE7BChsip6hQI7Rw5GlxC0CHPfR01/kGD0cWYp/BB4cdZl/18tcfhBAmKTt2zcIQjEdPPiruq8jnFGePLn9OJtZSIAESIAESIAESIAESIAESIAEYhsBeFfDUzsmvaxj2zVHd3vIL7qJsry4QoDzR9R7ivNH1BmyhMAIUOgfGK+HJjcm9KxZs+jfQ3PRvFASIAESIAESIAESIAESIAESeEAJJEmUQK5cM+Fdk0UuhOkDiiWgywI/cGQigYeNAOePqPc454+oM2QJgRGIF1h25iYBEiABEiABEiABEiABEiABEiABEohrBIKSJ5F/Ll+Ty1dvqsV/XGv//WwvLHTBDfzAkYkEHjYCnD8i3+OcPyLPjmdGjQBj+keNH88mARIgARIgsLvCTgAAQABJREFUARIgARIgARIgARIggThB4Gbobbl05bpcv3mLgv8Aegye8LB0huAzUcL4AZzJrCTw4BDg/BG5vuT8ETluPCvqBOiXFnWGLIEESIAESIAESIAESIAESIAESIAEYj0BCKzTpU4e69vJBpIACcQ+Apw/Yl+fsEUk4I0Aw/t4o8NjJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJBCHCFDoH4c6i00lARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgAW8EKPT3RofHSIAESIAESIAESIAESIAESIAESIAESIAESIAESIAESCAOEaDQPw51FptKAiRAAiRAAiRAAiRAAiRAAiRAAiRAAiRAAiRAAiRAAt4IUOjvjQ6PkQAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkEAcIkChfxzqLDaVBEiABEiABEiABEiABEiABEiABEiABEiABEiABEiABLwRoNDfGx0eIwESIAESIAESIAESIAESIAESIAESIAESIAESIAESIIE4RIBC/zjUWWwqCZAACZAACZAACZAACZAACZAACZAACZAACZAACZAACXgjQKG/Nzo8RgIkQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAJxiACF/nGos9hUEiABEiABEiABEiABEiABEiABEiABEiABEiABEiABEvBGgEJ/b3R4jARIgARIgARIgARIgARIgARIgARIgARIgARIgARIgATiEAEK/eNQZ7GpJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJOCNAIX+3ujwGAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAnEIQIU+sehzmJTSYAESIAESIAESIAESIAESIAESIAESIAESIAESIAESMAbAQr9vdHhMRIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARKIQwQo9I9DncWmkgAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkIA3Agm8HXQ9duLMBddd/E4CJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJBBLCAQk9M/8WOpY0mw2gwRIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIwJUAw/u4EuF3EiABEiABEiABEiABEiABEiABEiABEiABEiABEiABEoijBCj0j6Mdx2aTAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQgCsBCv1difA7CZAACZAACZAACZAACZAACZAACZAACZAACZAACZAACcRRAhT6x9GOY7NJgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIwJUAhf6uRPidBEiABEiABEiABEiABEiABEiABEiABEiABEiABEiABOIoAQr942jHsdkkQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAIk4EqAQn9XIvxOAiRAAiRAAiRAAiRAAiRAAiRAAiRAAiRAAiRAAiRAAnGUAIX+cbTj2GwSIAESIAESIAESIAESIAESIAESIAESIAESIAESIAEScCVAob8rEX4nARIgARIgARIgARIgARIgARIgARIgARIgARIgARIggThKgEL/ONpxbDYJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJuBKg0N+VCL+TAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQQBwlQKF/HO04NpsESIAESIAESIAESIAESIAESIAESIAESIAESIAESIAEXAlQ6O9KhN9JgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIII4SoNA/jnYcm00CJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACrgQo9Hclwu8kQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAIkQAIkEEcJUOgfRzuOzSYBEiABEiABEiABEiABEiABEiABEiABEiABEiABEiABVwIU+rsS4XcSIAESIAESIAESIAESIAESIAESIAESIAESIAESIAESiKMEEsTRdrPZJEACJEACJEACJEACJEACJEACJEACARC4GXpbLl25Ltdv3pL//vsvgDMf7qyPPPKIJEmUQIKSJ5FECeM/3DB49Q8tAc4fket6zh+R48azok6AQv+oM2QJJEACJEACJEACJEACJEACJEACJBCrCUBgF3L+sqRKkVTSpkomEEQx+UcACpIr10KVX/o0KSj49w8bcz1ABDh/RL4zOX9Enh3PjBoBhveJGj+eTQIkQAIkQAIkQAIkQAIkQAIkQAKxngAs/CHwT5EsEQX+AfYWFCTgBn7gyEQCDxsBzh+R73HOH5FnxzOjRuC+Cf3Pn79gt9y5be28deuWHDhwUI4cOSa3b/9r7Q73ef36Ddm//4CcPPk/uiaGIxN7v6CvT58+ow38559/xF3fR6b1znIjc35Uz7lw4YLgeu53Cgk5Kz///IvcvHnzfjclztf/77//ypdfzpdTp07f02s5dOiwLF26/J7WGUhlgc67P/20X1asWBWhiiNHjsrvv/8h4OwuXb16VXDuxYuX3B32uS+Q8z218V73vc+LYgYSIIH7SgDz83fffX9f28DKHw4CsAjEO9AvvxyUGzduPBwXzau8JwQQ0id50oT3pK4HtRLwA0cmEnjYCHD+iHqPc/6IOkOWEBiB+yb0f/XVdtpSCGb+7//eCtfqGTNmS5EiJaVDh87SqNGL8swzpeWbbxbbeaAEGDVqnMnzrPTt21/zVKpUQ/bt22/niesba9eul2vXYr8FARQu/nJ//fXOUqdOQ+nTp792z5Ahw+3tqPSXa7lRKcufcyH0XL16XbisffsOlEGDhobbdy+//PnnEalRo56ULl1RmjVrKYULPysTJ358L5vwwNUFYXS/fgPlt98Oe722QO4BrwXdObht23YZO3aCP1nvaZ7IzrsrVqyWjz+eZrf1hx9Wmjm9rNSu3dDMB43k2WfLyvr1G+3j+E1o1+7/pGjRUtK8eWspUaK0+Y3o4vd8GJnzXdsIYQsUL5ivmEiABEjAIoD5edSoMdZXfpJAjBDYtm2HPs+98EIzadu2o3mme0aGD/9QYBDFRAJRJYBnHIb0iRpF8ANHJhJ42Ahw/oh6j3P+iDpDlhAYgfsS0/+ffy5KypQptaWwYsmePZtu49+qVWvlww/HyNSpk4wwqITuh/CyZ88+UqrUs/LYY48KhEaffDJNFi78UvLmzaOeAO+++5506vSWER6ttMuKyxtvvtndCJ2+kUyZMsbqy1i27AcjFP1dnn66gNd2Hj16zAjK18qaNcvta+rY8TVj5Xvb63m+Dror19c5UT1++PBhI+B/XypVKm8X1a3bm+YB+v7o0G7fvq3C0UKFCup98+ij6c29sUgF1gUL5pdy5crY7eRG9BPw9x6I/prvbYnRMe8ePPirvPlmN+nY8XVp2fJlcwH/GUHGaIHibtu2DRIUlEJ69eonR48eNV4Ws3Ve2bt3n7z6anuZMGGSvP12F58XHdXzodDr1auvUTJck0SJaAnnEzgzkAAJkAAJRBsBeI7iN69LlzeMAvxVLXfr1u1mXzt956lbt1a01cWCSMCVwJHjp2Trzp/lr3N/S4HcOaRimWLm/cY1193vp/46J9t3H5A/j52Ux837R83KpSRlUDI7w/l/LsmmbT/K4SMnJUvGR6V21dKSJHEi+zg3SIAEHhwCkb3f/75wUeYvXiPlShaWPDmfCAdkz0+/yq4fD8ltIzMq/UxBKZAnR7jj/EICJOCbwH2RUiKsQ/bs2bV1sFDOnj2bbuMfBKoNGzawBf7Y17hxQ9Wmw60aae/eHyVXrpz68Ivv8ePHEzwEI2yMFToG+6Mjwdp+1649qliA8GnLlm3hij18+He1+sZDumv6668QI+Rep1asZ8+ecz2sYStwHJbyENwi/f33eVV8QOD0448/CYRk3hLOQ77vv//BhDr6OUIoJFgFwTV45co1dlmwTEZYDStduXJF24iwMM5QG3ev/baWAWtctM9KqG/Xrr2Ca9uxY5dcunTZOhTu89Ch3wQvLEi///6nhmTCNh4iLUuTu3X9a/o3PGdc4+7de7QMp4uzp3Jxvf/73ylUYSecb/UR+gXXinK3b99phI073FoRowyEJfnjjz/tcqBkWLt2g4bPwTWDpacE5Rb699dfD4WzBrl7re65uisP4UdcQyGhXFzLgQNh4Xx69uwmmTNnMoLKRPLii41VuYI2ekvexg/GyPHjJ3Scrl+/SfvNOT5QbkhI2BjHGLSOYYxgbDgTeF++fHd8nDnzl3Jx5jl82P29hPGA0Elgv3TpMucpEbZRB8YaBNSYZ5wJ5WAMoM/QLyjPNeH4ypWr/fZe8XYPeOp/q060A3W5jlXruLdP8MC85EyY+w6YkGjOhLEbxiLitXq6r5znO7f9nXdhAWKFywEDZ9q6dYfkyJHDCP1fk1SpUpq/VMajq51aL6J/0CbU06FDe4ESC/NDkSKFpFq1KjrHWGV5Grf+nu+tjVDmbd++wSjN3rGq4ycJkAAJhCOA3zs8O+AZAb+Drumw+T1btmyFzlvwPnImPHPhd2rDhs1unz1QHp7Z8PvL9PARwPNS/vz5pHXrV+yLL1nyGfN8l1nw3MtEAjFF4MCvf8qEafMlebIkUrxQXtm2+2eZ961nY7qDvx2RERM+N835Tyo8V1Tf68ZMmSuXr1zTJkKQN2L853L+wmUpXeJpOfv3RRk16Qu5ZZ71mEiABB4sApG932/dui1TPvtW9h04LOfOhw+VvGTFJlm4dJ3kyJ5JsmfNKJ/P/0F27Qv/rvtgUeTVkEDMELinlv4Q2DZr1koFQrgcCMwgHELauXOXTJ48Xl57ra1+t/7hZWnUqLGSIcNjRhFQXHfD4n/69M9k06Ytxv21lOAFau7cr+SJJ7JqPuvc6Pg8fvy4vPRSS7VK/frrb+W550qqxwEEty1bttG6ocDo2bO3sULtKk2aPK/VIubrgAGDTBiLZ1TQCEH0xIlj9Hxk+PzzL9VaPF++vEZYfkk9GHD9CCUybdoMLWPu3HnG0rWg5MmTW7+7/oNioFWr9kYoe1EVIFu2bDUvCvmNF8REFZZBqPjaa/8n6dOnlwIF8suYMeNVuIZ+ePfd3kb49qQsWbJM+vd/T4oXLyZnzpyR0NBQmTPnM+OJEWReOMOuvUqVynLixAk5Z6w+IFSdMmWiKmXmzp1vFA4/GqVLfFPndOne/U1jqZvTtZmyePH35sV3p+7/9NMZpp+eMO3JZ6zSZ2h5o0cPt+tq2fJlcXKGUujll1upkghWt1jDYebMqZIvXx6P5fbp018qVqwgnTt3sNvSokUbEzJlpFSpUkmWL18hn346U7ngxR3M4UEye/Z0gZU8BILduvUyipTlhktRfclq0KCevPPO26ocgeAZfYZrhrIJ3hjwRkmcOLEMGTJA65w1a46MHDlGihUrIriGNGlSa/nJkiWzr9UTV7vRjo1PP/1M29irV3fdiz5s2rSlzJjxiQpHd+zY6MgdJoyHYN2bp4iv8TN69HhV8pw9e1ZSpEihyoWKFcsbi+sxqmiDUKJ373fNGC+uYxAKneXLF+l4b9KkuQpOcR7CITVt2sJYT3c3fdlU24mykyZNYsZeHxV6eLuX2rXrKLVq1TD9vUTPwba7BKVg69btJVu2J9STaNOmzSpctuYUlFOkSGHTH39KggQJVPHVs2c3adOmlRaHe7Z79156X6DdWbNm0f3e/nm6B7z1P8ZXly49jNBnm7kPCsiePXvM9dU088G73qoKd2z37r3m3u5kxuZP9v5vv12s9/OiRfN1H+bNhQu/lZIlnzX3/gQzFjLp3ICD3u4ru0CXDX/m3bBx2cIob//QOQJtyJw5k11Sq1bNzZzV3P6ODQg4kDJnzqhziau3FgT5UHA9+WSYotjbuMVc5Ot8X23UxvAfCZAACXggEBoaan43XlclJeZSrDsyfvyHtlfd4MFDVUGNuRdKeRhf4PkCz7FQNuP3Dr9TQUFB0rXr2+bZd4I+K6C699573/yOrjThzQrrM3KJEsWNN9QQDy3h7geRAN5r8GclhNbDOw7WmKlRo5q1m58kEO0ElqzcLMUK5ZG61cto2ZmNZf4HY2ZKpbIlJH26VBHq+2HtdinzbCGpX6OcXL56TQoXyBUuz4atP0riJAmlRZOw5/ZihXJL9wET1DPguRIFw+XlFxIggbhNILL3+9xvVkreXNmMbOVKOAA3bobK96u2yqvNakuxp/PosXjxHpEFi9ba38OdwC8kQAIeCdxToT+EogsWfGHC94zTF5zy5cuaF56eJizP67ZAx2opBHgI1wPBM4TTixcvUAtmHK9QoZwRznVR99f06YONkPEfSZ06tXko/sw6Pdo/8XK2c+cmiRcvzDli2LCRWue8ebNVwH7w4K/GI6GZlC1bWh5/PIOx1l9j1ht4Rxo0qKtteeutt1XQD6XBoUO/yeDB75s41xMEDPBCiNjVCMnSokUzIwjtbYTJz8sHHwzyKrT96aefJUmSxEYIPk8///jjT43rjvJz584lX3wxz7QtnlGQTNE2vPJKc1NfVfnoo7FaL5QCvXv3M4LjqWpNi0ydO3eVESNGhxNAli9fRi3HISB/5ZW2qnBB6KXBg/ubWNsXNCTH0KGDtA53/7p1e0Mtpxs3fklGjx6hAnB3+bDPlXPHjm+afn7FdnGePfsLeeut7sZ6+TsjmPe/XNf68PI0deokHVvwUChXrooRmH5v6mpplB7zjEJps+nD7yVjxseNFd9ZqV69rjz/fAPtHwhtoXSaMmWCa7H6HQLKoUNHyqxZ08yLexG1gIeAfujQUeaFvp99jieudgbHBsYR4stDSA3rZ3gbBAenU4G/I5tuQojarVtPFSrUq1fb9bD93df4QcZz584ZJcxcFfrDMhHCCoz1/PnzymefzVZlGO5fJIwbCKMRTihz5kxqxVizZjUVbpsm6z0BoT/4bdiw0fAIE2T4updQNuaBjRtXCZQmntLGjZtMP1W1LbQx/qFcaN++jTLDeVBmLV++WO/jsWMnmnvhY+1zCIL79h2gSscuXTprFZMmfeKpKnu/u3vAV//PmfOlKjmXLVukcwi8NWrVqm+E88+YOPfuFRp2hX5uhIaG6hjFvV+iRDFVrPTo0Vs9oSB48nZfearCn3kXijBYp65bt0LSpk2jCqBatRqY+8h9mDLEzYfiCEq17NmzRagaXkToF3htjBjxvh73Z9xaBbk7P9A2WmXxkwRIgARAAHN27949zbxdXZ/fEFJs4MAhxjp/qRqC4Hdw5sxpkjNnDvW+LF++inpctWz5snmWXaoGKjBeQPr22++M4vdHfSbGfLhy5WrzLPK1/jbAyKJevca6cHCdOjU1P/89XAQaNmyi3qbx4sXXdxw8ezGRQEwRCDl73gju7xpvpUuTyjyzG0MiY/TlTuh/+sw5efyxYBn04XQ5+b8QSZ0qhbzYoIoUKRgm/A85e0GC095VFuAdOk3qFPKXqcddummeXa9dvxnOO9pdvnu9D+9dSZMkkkQJE97rqlkfCcQZAoHe77iwTdv3yZmQc9KsUTXZvit8lIDzFy6ZZ6zbZg5JbTPAnHTeeJFjf4IE8e392OD8EQ4Hv5BAOAJhEuxwu2LuCyx+EZYC4RvSpEmj2/v2/aSCXgjdnCljxgxqWd2rVw99aWrVqp1aUyEPLPwnTpxsBOO1jQC4s4kR3UmSJ0+msaBdy3GWGZXtRo3q2wJ/lLN581a1xPrll181pMa///6nQi7LcwHW6xC2IYzI/PkLjQX9LSNwO61NQMiV4OBgFbxjB6yOISBu0iTMS0AzufzDSyaE9Pj724RPQYKFNQTX8JjAiyTKRVlWiCMoWcADQlYkbCOGPoRxSHjRRHgN5ENYEPxhjYQ9e/bqcesfFBNIeFirVKmCV/di9C/ClaCdkQlb4uQMF3eEmIECw2pf1qxZVQBohepBuyKTIJTOkeNJPTUoKIVaJWNtAiQs1Fe2bBkV+OM7FEubNq2x82Oft4R+gBUfBP5I4Na4cUMV9DrP88QVlswWQ3CEUqhMmefUCwPCBCQoKOrVq+MsztxPF40HxyBT10vGEyKvUfrMtIXkkRk/KBweIClSpNB6oOjBtrWwbcGCBYwwYqksWrREvUDefruLbelYtWplHfs4ce3a9cYq8lUTjma3CkRwz1w1FkElS4at2eHrXkIZsO63BP7u+CBP69avyBtvdNT5AQo0sMM4wbxjpbJlS9v3Mbw+oPCBRwTGGbyK6tS5GyvXVQDvjqFVrvPTV/9DeQI+UFQiwbukfPlyEcaHVWZk7qmE5sUEHkIffzxVlS9wvYYlKgT+vu4rWBU6xx88qZD8mXf37dtvvJlK2XMMrrF06eesS7E/wRsKRKzV0q5da1Vw2gfNBtoAxVr16nVUwPbVV3M0pBvy+Jr3kMfb+f62EeUwkQAJkIArAcyvUDAj4ZkLv09QdlpecVCU37oVqhb7CxYs1Ocs67kM6x/BYxHzG9a0ql+/jlmotZWWhfCRBYz31//+d1qfeY4dO2Hm8YjPZJqZ/x4KAt26vaUGRMWKFTXPOK/ruHgoLpwXeV8IIOxOwoR37QET3dm+bgTxrgmvlhcuXpHtew5I/eplZcSATuolMO3zxXLhn8ua/dbtW6a88ILyhAkSmufyiOXhhNgo8Ee78B6NtjGRAAl4JhDo/X70xGn57odN0qZZPfNubqwDXVKokX8guc5JmHuu34h4P3L+cAHIryTgIHD3l92xM6Y2YcH0zTeLNJbp6NHjVPh27NhxI9zvZ8J/NDGhVyraVUO4iFAiSE2aNDKCpIrGUn6uxn+G5SeEw/3797Hzv/RSEyOorWwsYeYbYdLL9v7o2kiUKJFdFH78T5w4qUJNvLxZqWDBguaa4uvDQd++A038/60qRMyQIYOGQ7Hy4Vy8yDmT60OR8xi2O3R4Q8PvwNoAoWtgMY66Eb6nRIniGr4HMbKdqWXLZiqoq1Kllta3d+9eFb4WKJBfs+ElFYJOhKZxJqyX4Eyo00rgYCkRrH3Oz/HjJ5k4tj/oLih24KERSHJyRvuQ5syZa/jdHapVq1ZRBZAlNA2kfCuv85qwD/UijAgS+sc1hExSE4rG34TzIch1pnTp0mmIJOc+ZxucXKEoev/94ZoVeWbN+lSVCLVr11Qhe968uY0gfZ2x5n/TLg4hBlq1aqdeFHPmzLQ9N6wMkRk/1rnWJ9qCH154fCBBwA5PiBkzPtPwVhiHI0Z8oGGIKleuaKzJ39C8EPrDmwRCf6wNcPToMfWIwZj3dS9ZdTvHhSc+8+YtMF5EY7XvoHRBqBfX5Mocx3E9p0//pfNR1qyZ7VPSpUtrb2PDHcNwGe588dX/J0+e1Hi9znODg9Op4sG5z9qO7D01adI4w32WsUAdrGEBGjasLwMG9FHhFMr2dF9BIdOkSdgcCl5du75p1lmppxb3vuZdhAgrVy5MSWi1H0pGjE8rYY0BhFHCPAaPHXhGOROUNG3bvq7Wjf369VahmLPffM17vs73p43O9nCbBEiABJwE8OyBtaSslCvXU7qJMD+JEyfR32IYU0BZj7ndOX/BE27kyKEm3M8c44k2zihiMxjPyv5qeACPNiirnc9kODe9CdHI9HASwBhCeuGFRuppOXz4KPO77tsL8eGkxauOKoGUQcmNZ+hdQ5mrd4xmnAvzWnWYqUmC06WUnNmzytP5w+bAejXKyuoNu+T3IydUAYDyXK36r5ky3ZVnlctPEiCBuEkg0Pt9+hdL5NHgNLJuyx69YMw3e/cf0jU/ypcqIqmMUSbStWvX9VO3TR4YU2LdESYSIAH/CdyVpPp/TqRzwj0Z7tDPP9/UWDlNUQvOPn0G2HGmUXCPHn1U+Dpq1FC7nqRJkwoEcAg1AqtnfOJFyZlgBQyh96lT4RdwdeaJrm28hOElD6FTmjd/yS42JASxz5OrJfRXXy3Q2NKwrEWyFhDFNoTqsP6HsBETFxJe9PA9S5a7Qkc9cOffggVfOL/q9uTJn0iFCuXtOPI4f8CAwXY+LIwZGhpqlCN9zUtjOg2hhBdRK6EdUFJMnDja2qUT6+XLl+zvgW707dvLCAd7BXqa2/xPPfWUvixD6Gi9VOMaYZn96KOPuj0HO3FN1687fiDMjwU8HPxN4GJZ1FvnHDz4q1pJ+6NowPkQbDrT0aNH/fYUgMLBVemAsmARiDjuhQo9rUocrGFhpW7demnM9unTw9YWsPZbn5EZP9a57j4hrEdYLSjrELLn/PkLJk792zJu3Ec6HgsXflr77quvvlaFSrZsWaVy5Upm0eu1qlR50Sw0jOTrXnJXtyc+CC/Ur987el/iPCx0O2nSFHdFRNiXIcOjev/BChweOkgYZ87kjqHzuLXtq/9z5swZYRFhWHxanidWOdanu3vKUmhAwJ0kSdg9fflymEU+zoNXD9jC+wJ/sKxv2bKtWskjTA+OebqvIMzauHG1Vb1++jvvPvbYY7rOh/NkJ0esC/L2273NvNnMzPVdndns7bFjJ5g1AX43oeDmug1v5mve83W+rzbaDeEGCZAACbghcP78ebl586YdchKKXszJWc06MHPnfqVrFcHa30rOBegxB5Yq9azxmiyvz2cIMwdDlhUrlqhXY5AJJQmvLCvBgw+eWkwPD4Evv5yvCvuFC8NCd1pXniVLFhMq8+46PtZ+fpJAdBGAAO7kqbN2cadOh5jnRQj3wzzE7QN3NjI8ms6txa2lFEV5P+7/zRj44HnfPJuaGN3n/v5HBX2uZeE7QujERmtdPDOjbUwkQAKeCQR6v4fNH9flz2MntVB4GoWcMxEj7sxBQSmSmrX8EuuclCNbmHzs5Omzkj44tb7HuraE84crEX4ngbsE7poq3d0Xo1uIpf744xm1jj/++NMIorOFqw8x7xcvXmKsoL7Q8D94QcJLEV6qEI4jQYIE5mWposYTR5gMCLURdgOCHrhPV6tWOVx5MfWlZs0auuAuhPVI69dvNAL4asa9+5xtYYw41EgIlbFq1Rrdxj+ESYEQevLkqUbIfk0Fpm3avK5x73E8efLk+NBwLbrh4R9YYIFdWKhDCDtr1hfhJsErV64aV+ADxiK7q1kfoYuJR9/GLMI6WcN7oEgsUgtra7QDZSCMB6yzR40a56HGiLsRVgnhR2IiIf46rJxgDYe2oY2wekZceW8pd+5cxq1+hSpScM6sWXPMy/ldZYe3c3EM42yrWWR1+fKVKghGjPwXX2xuBKk39VT0D9hCEOouoX8hEJ8+fZa2+fjxE7pwcFQXYEM4HQgEYOkFBYCVIBTYv/9nDRd16tQZDRkAITL+oIjylHyNH0/nYT8egFu3fs1edDplypTmhzmpCcGTVE+DMgv36ciRo22PncqVK2i84p9+2m/ulbvW4N7uJW9tcD0GLwR4ESDBKmDBgm9cs3j8njdvHo2zjJALEFJjLsFYC7pjZeDxRHPA9R7w1f/waEJYpJ07d+t9u27dBuORs1lD/qCeJEmSaBswN3hKTz2VQxWGGNsYh5hX16xZa2e/ePGizke7d4dZT2ChaiT0T2TuK4wVf+bdGjWqavi2ZctW6NhftWptuHBhCB2G64K1qzVGrc9Ll8LcwRFGqGjRomZuvxUuD+4jJF/j1tf5vtqolfAfCZAACXgggHkUa1Phtxe/OfitKFOmtD5PwSsRSgHruQjPqYcP/26XNGHCJKNw7aFKAzx/pUmTWn87kaFatSrmWRK/B1s0P54va9Wqb5Tl6+zzufHgE8D6Pvi9Gzx4qMAbGh65S5Ys07COGCNMJBBTBEoVLyj7DhxWS31Y5C9fu03y5c4uqVOGWdyu27xHlq/ZaldfsXQx2X/wdzly/JR5X/pPVq7bbp7R4kv2JzJpnhJF8snlK9dk7eZd+ky3bPVW8z6WUArlD+9RbhWImPmpjHcA6otNf2gT4/lbvcRPEnBPwNf9/reJ0T9nwQ8CwT3S6680kLfaN7X/cM9XLV9CXmpUVY9D1lCyWAFZvXGXCSV22XgNXZAtO34ST4uAc/5QbPxHAm4J3FNLf7QAD7I5cmTXxuCFJnv2bLpt/cOCpRCoTp48xbg8f6BCMYTq+PDD4brQJfINHTrY/I3QRWdv3Liugv9s2bIZj4GP7DjqVnkx9fnaa23UmgteCxAs4+UNC01alvqwfoZQFJZfaH/Tpi+oBRjag5AoU6Z8pAuzTps2XZsIi2ksemodr1KlsjmnuRQuXMgoOKbpftd/r7/eVkOOlCxZXkOqWOFWkA8xrZct+8EIq18woTnq60sDlA8QaiLUBjwp4Bkxc+Yn6l0xdeqnKtRGaI6ePbu5VuXxO8J94AX26aeLm/jhE9WCzWPmSBwYN26UsQzuY4SEVfSBEjyxz7IicVdk165vGEVHNyNsrq4KFCzAixj3/iYIZVHGoEHvqwUe6sKiypbgtGzZ0sqxcOFndeHXzp07hCs6U6aMxsJ8nAwYMFjGjBmvaybUrVtLF5QNlzESX7Dg6fjxH4XzBLh0KcwzY9SoMaZfx4QrtU6dWubeGRZun/XF2/ix8nj7HDZssBkrfc0Ymq2CXFi49+/fxz6lcuWKAo8XWJYjZc6cSS23oSBwekz4upfsAn1s9OzZ3axp8J4R9i80MeXTmjU+uhuPmq99nBV2GFaaWGQaY7ly5Zo6vjp16qgKRV8FuLsHvPU/4vljIfI33+yucwi8mAYM6KtKONQFgTgWGEa4sg0bVhuBUEQXRswhAwf2k2HDRun6JhDkt27dyiy6HKboQDiIIUMGmoW231IlAtYBgYcEykaKzH3lz7xbv35do2j8RTliTsR82KXLG6rERb1hVqviVnGHEBcvvtjYhO66aJRDq/QP51gJ17Rp02rxNW59ne+rjVZ9/CQBEiABdwSqV6+m3oTlylXWZ60iRQqZuTjMy7J27Rry/ffLzFomlfT5Fr9/FU0oMyt16tTBhLR81xyvqM+N8L4cPvx9PVysWBHzrDHY/I4OUqUBvAleeaVFhPV7rLL4+WASgBcnFnrG80y1anX0PQi/8W3atDK/6a89mBfNq4oVBAoXyCWVy52WMVPmya3Q20Z4/7i0a1HfbtvPh/4wz2hXpXrFkrovb65sUr9GOZky81u5ZJRTENp1fLWRCu6RAcLyts3ryecLlsu8b1aZhX6DpEOrBmbuu+fiB/sauEECJBAzBHzd75eNfG/9lr1G6feUZMoQ7Fcj6tUoI+fM+ny9B09Wb6FniuaTymWL+3UuM5EACdwl8IixEPfLb/jEmQuS+bGwhSfvnh6zW7CaxwuRN2tbWDLD+tkKcRGzLYpYOvAhtIm1OK4zB0JvYDG3FCnCLCScx6xtCMEQEsgK12HtxydC2UDLiT9vCQI9WIs580GwX716XaNo+CycIuTjj6epUBSxtJ0JlvSwUIssRygZvAninXVFZhvWzFAGua5b4K0sxNcFE2/jx9v5OAa27voWx/y5ZvQv6rfCOOG82JbcjZ9A2ohrhOUOLP2jkrzdS/6Wiz6B0Bf3Q2QTeOCeTJQoMFded+PBV/8j7JdTAeJsM+5Jy+vHud+5jTr//vucCX+WzuMYwzyaOnUqtZB3novtyNxXOM/XvBsaGqrrbkChEVMpquP2XrQxpq6d5ZIACdx/AvBawnOau3kacz88AqD8dJfwfHj9+jWP8z9+G4KCUsboc5W7dnFf7CJw+fJlM05u6NoQsatlbE1cJuDrnR7z2vUboZLMhNbwN101awF4y3/ZrBeVwsyJD1LyxfFBulZeCwlYBPwZ99F9vyM0GBb7TZjgwVEY+sPRYs5PEogqgVgt9I/qxT3M5+OBrVOnribsy36zCHIp9TiAZwVcxxH3nC7CD/Po4LWTAAmQAAmQAAmQAAmQAAk8bAQobIqeHifH6OHIUuIWAY776OkvcowejizFPwIU+vvHKc7mQizQgwcPaVilNGnSGKv/Ql49D+LshbLhJEACJEACJEACJEACJEACJEACHgmc/OsfyZg+ZTgPcY+ZecAtAXgn/y/komR6NJXb49xJAg8qAc4fUe9Zzh9RZ8gSAiNAoX9gvJibBEiABEiABEiABEiABEiABEiABOIcgXMXrkhiE5YzRbLAwljGuQuNwQZfvnpTEHIkXerkMVgLiyaB2EeA80fU+4TzR9QZsoTACMQLLDtzkwAJkAAJkAAJkAAJkAAJkAAJkAAJxDUCQcmTyD+XrwkET7A4ZfKfAHiBG/iBIxMJPGwEOH9Evsc5f0SeHc+MGgFa+keNH88mARIgARIgARIgARIgARIgARIggThB4Gbobbl05bpcv3mLgv8AeuyRRx6RJIkSqMA/UcL4AZzJrCTw4BDg/BG5vuT8ETluPCvqBB6cJbCjzoIlkAAJkAAJkAAJkAAJkAAJkAAJkMADSwACa4ameWC7lxdGAjFKgPNHjOJl4SQQ7QQY3ifakbJAEiABEiABEiABEiABEiABEiABEiABEiABEiABEiABErg/BCj0vz/cWSsJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJRDsBCv2jHSkLJAESIAESIAESIAESIAESIAESIAESIAESIAESIAESIIH7Q4BC//vDnbWSAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQQLQToNA/2pGyQBIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARK4PwQo9L8/3FkrCZAACZAACZAACZAACZAACZAACZAACZAACZAACZAACUQ7AQr9ox0pCyQBEiABEiABEiABEiABEiABEiABEiABEiABEiABEiCB+0OAQv/7w521kgAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkEC0E6DQP9qRskASIAESIAESIAESIAESIAESIAESIAESIAESIAESIAESuD8EKPS/P9xZKwmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAlEOwEK/aMdKQskARIgARIgARIgARIgARIgARIgARIgARIgARIgARIggftDgEL/+8OdtZIACZAACZAACZAACZAACZAACZAACZAACZAACZAACZBAtBOg0D/akbJAEiABEiABEiABEiABEiABEiABEiABEiABEiABEiABErg/BCj0vz/cWSsJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJRDsBCv2jHSkLJAESIAESIAESIAESIAESIAESIAESIAESIAESIAESIIH7Q4BC//vDnbWSAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQQLQTSBBIiSfOXAgkO/OSAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAncQwIBCf0zP5b6HjaNVZEACZAACZAACZAACZAACZAACZAACZAACZAACZAACZAACQRCgOF9AqHFvCRAAiRAAiRAAiRAAiRAAiRAAiRAAiRAAiRAAiRAAiQQiwlQ6B+LO4dNIwESIAESIAESIAESIAESIAESIAESIAESIAESIAESIIFACFDoHwgt5iUBEiABEiABEiABEiABEiABEiABEiABEiABEiABEiCBWEyAQv9Y3DlsGgmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAkEQoBC/0BoMS8JkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJxGICFPrH4s5h00iABEiABEiABEiABEiABEiABEiABEiABEiABEiABEggEAIU+gdCi3lJgARIgARIgARIgARIgARIgARIgARIgARIgARIgARIIBYToNA/FncOm0YCJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACgRCg0D8QWsxLAiRAAiRAAiRAAiRAAiRAAiRAAiRAAiRAAiRAAiRAArGYAIX+sbhz2DQSIAESIAESIAESIAESIAESIAESIAESIAESIAESIAESCIQAhf6B0GJeEiABEiABEiABEiABEiABEiABEiABEiABEiABEiABEojFBCj0j8Wdw6aRAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQAAmQQCAEKPQPhBbzkgAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkAAJkEAsJkChfyzuHDaNBEiABEiABEiABEiABEiABEiABEiABEiABEiABEiABAIhQKF/ILSYlwRIgARIgARIgARIgARIgARIgARIgARIgARIgARIgARiMQEK/WNx57BpJEACJEACJEACJEACJEACJEACJEACJEACJEACJEACJBAIAQr9A6HFvCRAAiRAAiRAAiRAAiRAAiRAAiRAAiRAAiRAAiRAAiQQiwkkiMVtY9NIgARIgARIgARIgARIgARIgARIgASiicDN0Nty6cp1uX7zlvz333/RVOqDX8wjjzwiSRIlkKDkSSRRwvgP/gXzCknADQHOH26g+LGL84cfkJglRghQ6B8jWFkoCZAACZAACZAACZAACZAACZAACcQeAhDYhZy/LKlSJJW0qZIJBFFM/hGAguTKtVDllz5NCgr+/cPGXA8QAc4fke9Mzh+RZ8czo0aA4X2ixo9nkwAJkAAJkAAJkAAJkAAJkAAJkECsJwALfwj8UyRLRIF/gL0FBQm4gR84MpHAw0aA80fke5zzR+TZ8cyoEbhvQv/z5y/YLXduWztv3bolBw4clCNHjsnt2/9au+Xatety8uT/3P6dPXvOzscNEogqAYxBjDV8MsUsgZUr18iPP/4Us5W4lP7PP//Il1/Ol+vXb7gcuf9fL126LFeuXInQkKtXr8pPP+2XixcvRTjm3OFu7G7atEW2bdvhzBbQ9qFDh+W7777365xTp05HyGfN6adPn4lwjDtIgARIIC4QCGQejAvXwzbGXgKwCMQ70C+/HJQbN2Lfc0rsJceW+SKAkD7Jkyb0lY3HvRAAP3BkIoGHjQDnj6j3OOePqDNkCYERuG9C/1dfbacthRDr//7vrXCtnjFjthQpUlI6dOgsjRq9KM88U1q++Wax5lm1ao1UrFjd7d+bb3YPV05c+AKh8r59++NCU6O9jWvXrlclTrQX7KbAyNQ1aNBQHWeHD//upkTuik4CU6dOlx9+WOm1yOi+V86c+Uv69Rsoly55F6B7bVQMHLxw4YK0a9dRvvpqoV065sl27f5PihYtJc2bt5YSJUqbebOLx/vH3dj94ot5snDhIrvMQDe2bdsuo0aN8XoahBRLly6XOnUahss3atRY0/aS8tJLLaRcuSpSq1YDOXbseLg8/EICJEACsZ2AP/NgbL8Gti/2E4CCvnTpivLCC82kbduOUrjwMzJ8+Ic0Qon9XRcnWohnNYb0iVpXgR84MpHAw0aA80fUe5zzR9QZsoTACNyXmP7//HNRUqZMqS2FFUv27Nl0G/9WrVorH344RqZOnSTPPltC90+c+LH07NlHSpV61giTauqffYLZgFVs9ep1pFq1Ks7dcWJ72bIf5Lfffpenny4QJ9obnY2Ekmbp0m8kU6aM0Vms27ICrQuCy6VL/bNqdlshd0Y7gYfhXmne/FX1cIKVf40a1WyGvXr1k6NHjxrPhNk6V+zdu09efbW9TJgwSd5+u4udDxv3a+yuXr1OevXqaxQR1yRRorsWZJ9/PlemTZshY8eOlAoVygm8ALp06SFdu/aU+fPnhGs7v5AACZAACZDAw0wAin/8vnfp8oZR9r+qKLZu3W72tZO8efNI3bq1HmY8vPYYJnDk+CnZuvNn+evc31Igdw6pWKaYURB4rnT7ngPy4/7DJs79NXkicwapUamkJE2S2D7h/D+XZNO2H+XwkZOSJeOjUrtqaUmSOJF9nBskQAIPDoF///1PDh4+Irt+/FXKP1dEsmZ6zOvF+TM/7PnpV1PeIbn9720p/UxBKZAnh9cyeZAESCAigfti6X/kyFEj6M+urfnzzyPhhP6HDx+Whg0b2AJ/ZGrcuKFq0+FW7S6NHj1OHn/8cWnR4iV3h6NlH8JprFmzTq3yb9++bZd54sRJOXToN/s7NtDO48dP2PsgwMMD+4YNm8NZ5u7f/7Ps2rVXEJZox45dqrywToJiBPX9+uuhcJYECG+0a9cetfZBvbCORpgSJITNWL58pfz++x9WMV4///orROtYv36jtsE1c0jIWUFIELQb148wS/juTLCCh7APLynOhDaAAc5bv36T7N9/QP79NyxM099/n1flDoSDCOly8OCvzlPdbkM5hHp27txt2nFbLl++LLt379W8EICiTHDE9aM8y/oiMnWh3QMGDJb33uvvti0oG+7W8B5AP/mbwGrZshXa17DcthL64eeff9Hr2r59p4ZgQT87k7sxFBoaqmMBn1ZC252hVcAY48XigXze+gzjGX2JdroLu2XVA/4Y0xh/uJ+dCf2BMmCZjzF89Ogx52Hdhqs6xtLGjZv9slyLzL1iVerpXrKOe/vEmAU/KBathL7APmfYsT/++PMOi4jXivM8MbfKtD5nz55uxvUWSZ8+2Nql42Lv3h+N51N7KVSooFpnFSlSSJWcmDecydfYRV6MCShXcV87x6FVDq5v/fqNOiate9Y6hk/sgxXiihWrJCQkxD5UqVJ52b59g/GeeMfehw2Mk0aNGkjVqpUlYcKEkjVrFmnW7EUzJ/wcK0MrhWs8v5AACZCAGwKe5kErq6ffexzHHOvumdA6F/MqQt5hPmd6+AjgeTB//nzSuvUr9sWXLPmMZM6cOcL7hp2BGyQQDQQO/PqnTJg2X5InSyLFC+WVbbt/lnnfevbC/X7VVlm0bIMUKZhT6hph/t8XLsqw8bPNc33YezK+jxj/uZy/cFlKl3hazv59UUZN+kJuOd6jo6HZLIIESCAWEPj196Nm/vjKKPl+Mn/75NLliGFqnc30Z35YsmKTLFy6TnJkzyTZs2aUz+f/ILv2HXQWw20SIAE/CNxTS38I+po1a6UxqdE2CH0Qnxpp585dMnnyeHnttbb63foHoRRCQ2TI8JhRBBS3dtufEHx/8cWXMn36JxIvXszoMD7//EsZNOh9yZcvr4YCeeyxR7WtKVKkkNmzvzDCsQMya9andpuGDh0hOXI8KX369FSBZ8uWbSRbtickKCjIWLe+bc6dIMWKFZG5c+cbofePEj9+fPnkk+nSvfubJk9OU9YcGTlyjOaBUiRNmtSmnumSLFky8xJ43ITIaGnCY9RQoSq+Q/jYtu2r8vXX30iSJElU6D1ixAdSr15tu02uG4jNPWDAIBM66RkV0EKIPXHiGHnuuZKaFe357LPZKliEwLNXrz6SNGlSvY7SpUup8gLXhZdXKHB69uxtLI67SpMmz+v5o0ePvyOIPyvgdODALyZUTnljmTzGeDYcVstfZJw7d56xXC4oefLk1vNc/0GgDavgI0eOmPMraDkQsN42D4wvvPC8CRlSWEOhVKtWRYWQOXM+pWOpcuVKpq4PA6oLdaM+eAW0b9/GhJgq5NocZdW0aUsVfGJM7tnTVYYMGeiVNQoZPHioscBeJiVLPqvXgPjm6FOUsXz5Cvn005lG0JteywUfjDEcf/TR9B7HEK79jTe6yQcfvGdCppTRtr7zTj9JmzatjBs3Sr9DeD916nRZsmShX32WIEECVUrg5PHjR5mxV0TLcf6DUqt16/Y6FuCxs2nTZunY8TX73kVomiJFCsuff/4pKA8KoJ49u0mbNq20GCgJnn++qbEGT6RWa+PGfeQ2fr1mvvMvMvcKTvV2LznL97R9/fp1vd/QF888Ezb/4PpxD+7cudl4LAXp/LRw4bfat2PGTDCeK5nM/TxRi4Tyxtt94qle537MD+vXh3/pwviHQvDJJ8OUp8jva+wiz/HjJzRcQIYMGbSfg4PTmft8mu1ts2TJMunf/z0pXryYnDlzRsucM+czvU6rjjZtXtf7D3MTlHrjx39ojz/kcU047powZ6ZLl9bMV3etwVzz8DsJkAAJxEYCmGu9zYPefu+hBPf0TIhrfe+999V4Ab/veEYuUaK4CesyJDZiYJtiiACesfFnJTzjz537lRp0OD0AreP8JIHoIrBk5WYpVsh4k1QPe6fIbCzzPxgzUyqVLSHp06WKUE3IufOSKlUKKV44rx4L+fsf2fvTb8Yi919JIPFlw9YfJXGShNKiSQ09XqxQbuk+YIJs331AnitRMEJ53EECJBB3CeTO8YTgD2n3Pt8Gnb7mhxs3QwWKxVeb1ZZiT+fRcuPFe0QWLFprf9ed/EcCJOCTwD0V+idOnFgWLPjChO8ZpwLt8uXLaoiHTp1eDye8QqshWOvU6S0VckOAvnjxAhUSul7Rxx9PM2UVNQK3Z1wPRcv3Q4d+MwLb9+XjjycI2gthLWJqIzZ2ixbNfNaxePFSeeKJrDJz5lTN++233xlB8Y96/YMH9zdxuS8YQX8KGTp0kB6HIG/o0JFGWDnNCLSLqBAYQuahQ0eZl8F+dn0Ik9GgQV0VulWqVF0Fr0uXfmsUCPGM8L23fG5CangT+q9atUb69n1Hy0Chb731tjnnSxX6w4ob3hNjxoywQyYNGTJMLeunTp2kbRg2bKSkTp1a5s2brZbHsK5v3LiZlC1b2nhdZNA8586dM4qIuSr0h1UbXnSRD2Gb+vfvbVyUnzcC60G2wFFPcvm3Zct2tRZfu/YH2/q5Xr3GUqbMc9K5cwc799at28wio1+rkBx9Vr9+Y/n++x+kdu0afteFwkaMGG2EkenMC/0rRuj5l12+tfHuu4OMtRWEuh/pda9bt8EIvN80QtKikjHj41a2cJ+WV8LMmdMkZ84cqqQpX76KWoa3bPmy5j1lQp6ALcY6lCyIe75kyffGnbulGfuex1ClShWUD4T+EMDCowLKr9DQULWqRvuQB8mfPtu1a7cJITNLr1FPcvNv48ZNJpxWVduiG7HioeSBogQx6pAgDF++fLG2ZezYifLRRx/rtaBt7777nlqx4Xoh+If3xssvtxKMaU8pMveKv/eSpzr92Q/O06d/Zv6mGOFMMVWs9OjRW71uoNDxh7k/9TjzwKOlb98B6mExYsT79iFfYxcZIUTCfZIlS2b1EHrxxRZGaD9J5x94ZvTu3U9mzJhqK7w6d+6q98SgQe9qPfBK6d27p1E6Vte5EGGHBg4cYqxSl9p9bzfIzQZ4IVwblKXvv/+emxzcRQIkQAKxm4C3eRCGEPBC9PR77+33HKHZVq5cbX77v9bnKzw74HkHRhoIbcn08BFo2LCJwNAlXrz4RvD/mXl2ChOuPnwkeMX3gkDI2fNSuEBOu6p0aVIZT2GREBPqx53Qv0r5EjJuyjwZOn6WIO/+g78bhUFpSXwnxGPI2QsSnPausgDvAGlSp5C/TD3u0ndLd8vUT9ea95lr7g7H2L6v57/ptWy82yRNkkgSGW9VJhIggegh4Gt+OH/hknoNBadNbVeIeea8ibIAb6IECeLb+7Gx4dQOWXR4mVy95d3DINxJ9+BLsgTJpd5TNaTs42Fhy+9BlayCBCIQiBnT+AjVhO24fv2GCpoQqiJNmjS6vW/fT2oBDy8AZ8qYMYO8887bxsK8hwpJW7Vqp0JNZ57//e+UWk+3atXSuTtatxE+Izg4WAX+KBiWyxDIN2kSZtHuqzLE6ocgFoJBhKipX7+Oscpv5fE01Jct2xMq8EcmPCAhvBE8IZzJUnJAuPrEE0+oNRgE/kiwEEOYFiSE8gAnCPTwB6UF0ujRw1VIifAr8+cvNELiW0ZQeVqPJUiQ0AiME6gAU3eYf1euXFULcuv75s1btZ5ffvlVY5AjhlvatGlszw3kg7UwrPyRIOjHNqzYPSW8SFvtRFgeJFgC/2tiuEj28dUAAD56SURBVN28eVO/w6Ue1tewZncmKGRgFY+UK1dOKVAA3H92Zgm37a4uhDxB3PgRI4Z4FGBCedG4cSP7OOqFJwbCFCG5KxfXDeXHrVuhasG3YMFCYxmTSgXDVqMyZ86kAn98DzJKIPDCWg9I3sZQ1aqVVOiPfBtNqBx4ajzxRBYTOmCH3jewwq9UqYI5KuJPn5UqVdIW+MO6zDl2IMxAat36FeNh0FHD80D5hT5DOB/c31YqW7a0jl18r1KlkioyoET5z7w97Nu3X5UGEPgjQWECzwYrIVyVVS8+PSVf94qv467lerpXXPM5vyNcDbxUPv54qobLEflPLd8h8EfyxdzdeHGW79xGf2AewfolOO+rr+boWEcef8Yu8iE8EAT+SBiDGL+7d+/R71BGYh+UswcOHNQ/xA/esycsjBYy4Xqh8EHCXAiPI3gPnD17Vvd5+4dwWLVrNzTt/lq9ijCvMZEACZBAXCPgbR709Xvv7fd8y5Zt+uzyv/+d1vn32LET5vcl/Bwc11ixvVEj0K3bW2qgA+Om1q1f13ERtRJ5Ngl4JoCwO3j/s1KiO9vXr4e9g1n7rU94s8Z7JJ4JFXnNhPC5KP/9a94Xr959F7h1+5Y+N1r58ZnQvGN6Ku9+CPydbfO0jXeXax4YeDqH+0mABLwT8DU/hN6RWbnOSVBEXr8RcU6KjQJ/EIASAm1jIoH7SeDuL/s9aAUsmL75ZpHGMoUlOQTax44dN8L9ftK0aRMjHKxotwIvTggHg9SkSSMjzKyo1usdOrSz80BYDWEhYknHVILwHC9dzoQXPn8TLLBHjhxqLFvnqPU8wmoMGtRfhbruykB9lvDaOg7L8xMnTlhf9dOyqA63884XCOP+w5OXSRDqv//+cN3GOQhDBM+Dvn0HypYtW431WC0TYiaDeghoJvMPgnbEsx8wYLAsWvSdCmwhiEVoHiQ8/KCdKBsKDSsVLFhQrZGs785P1I1JG0J7T6lDhzc0pAjyIpQPPBsgEMbYaNjwRVVs/PbbbxoT/MUXG4crJmfOp8J9xzWeM5YpnpK7uj78cKxanmOBUaQbd35Q+vcfrIoYeCdAuO3aPwiRAsEnkrtyYYHfqlU7FabCQwH5XfvP9TsE4gjhguRtDEH5c+HCPxrnFUJVWMtDILx69RpJnjyZCmYh6PW3z5xjG+FdmjQJ80RA+7p2fdP0Qz3j3bHAeOuMVYEvFFQIP+OanNdjCffR95dNfD+E7EL/OBNCvVgJludQviBBOQgvH3fJ173i67hrme7uFde+dj0H3ydNGiczZswyFu+D1f2+YcP65t7po1x83Sfuxou7OqBQadv2dbX469evtyoPnYx9jd1hwwZrsVBgOhMUZLjHkTCG0TewxHcm5LESvHss5SL25coVdt9hjCM8lacELwQwateutQkD1UZDhXnKy/0kQAIkEJsJeJsHEydO4vX33tvv+fHjx1WJ7pyDMc97m1tjMye2LeoE8MyI9MILjdRbdvjwUea39JOoF8wSSMANgZRByY3B112h/dU7xjwpg5JFyA3B29TZiyV/nieleePqehyLAA8bN0tyPplJF9tEea5W/ddMme7Ki1ABd5AACTzQBHzND6mMESQSlItWwvwB+SHWHWEiARLwn0AC/7NGPSfckxEWAvG8EQ4Dwsk+fQbY8a9RQ48efVTYOWrUULtCxJKHUBDhYpzpu++WGsvRmrZFsfNYdG1D4AXlAgSWmGSQYNmM77CYhcDTORnhOASbVoLguVSpZ1UxgdAWCHWC0BwrViyxsoT7RH0/mMVRneno0aO2Fbhzvz/bsMTFnzMdOvSbsbZdoHHCLYtka+FV5MO1wQW9hQlfVKFCWY1R7rTExksohH0IH9S8+Ut20SEhiN+f3P4e6MaCBV9EOAWLE8O6vl+/d1RQDCFzypRBEfIhbrwzwTMCygJPyV1dr78e3psEAtAdO3aaWO4l5KmnntQ1FTJlyqiKKnhTIIHVsWMnzPEc+t1dud9+u1gXHoa1v5UQ39/f5G0MQaAOIULYwqwbzboQb5m1FP42gtVOarVdoUJ5e9wG2mcIV7Rx4+oIzYQAF/1hhY/CoraTJk2JkM/dDngx4H7GYr/WyyzyYS6wUt++vcw90sv66vHT173i67hrwe7uFct7Ad4lVnLe3/BQwv3w9ttd9A/jsGXLthr/H3x8MXc3Xqx6nJ9jx07QxYAXLJjrNhyWr7FrlQVvC2fCXGYtqg5eCCEwceJoOwvmtsuXL9nfz58/r143liIHSg3MgVmzZrHzuG5AGfXJJ59qSCx4FjCRAAmQQFwm4G0enDv3K6+/995+z3PnzqWer851ULAQPTzImB4eAl9+OV+V5AsXzgu37k2WLFmMp2SYV+nDQ4NXei8JPBqcRk6euuu5eep0iHnGFQlOlyZCMy6ad12E3yiY90n7WLYsj0tQimRy9PgZFfqjvB/3/2YMj0TLQYzucybuP/a7S21bV7gv4X3ctcW5D8/5CO/DRAIkEH0EfM0PQSmSGplBYp2TcmQL81I/efqspA9OHcF4Eq1CCJ3YaO1vhfeJPnIsiQQCJ3BPhf5o3ikTu/zxxzNqS//4408Tyz+bblv/EJ4EMbGxiGrdurU0ZtdsE/8ZwqUqVSpZ2VQAhgVBq1WrYu+LiQ2EWUF4mcmTp5qY5C00hEmbNq+bePIdVeiPl7Rp02boopglShTT+OQIYQPraqQJEyZpGJexY0eqFTlCwUDoaSVYY8OK3kqob/DgoUYpMssID5tpmBMs8goBfHQlyzIb/CD0RwiVVavW2MXDKjwkJESmTNlk1mD4xgiPU2oYkXr16theFTVr1tDrhjcGBOHr129UK/dlyxbZ4UPsAt1sJE8ephzACy3O95Ru3rypFvu9evXVmP5YOBbW/wixky9fHvu0b7/9zgih6+g+hA+BcLNMmVJ63N+6MN6c6fz5CybUz4dGsVTdXmgYYxDx6WFhD4t9WOShP4sVC1MCOM+3tuPHTyAQEqCfET4FSozDh3/XuPZWHm+fvsZQ5coVzZj5QDnCMh1/UFB9/vkXumaCVXZU+8wqBx4bR48e068QCmOMBJKwEB0UdlAo5cjxpFlIdo7xqrhrWeSprEDvFV/3EsLYIP355xF7vQjXupMYrxd4JWBMFSlSWF9aFi++q7C7ePGi8UqpYa5hqobkspRjyZKF3ePRxXzTpi2m/KIahgthwqwEq3soH/0ZuzgHcxPuFax1gbjTEC5g3Qgk3Ffw9MBc167dqxpGq1OnLsab6jF7zRFcF9Zk6dChvXq9wCujTJnSEdy3tcA7/9B2jEmEIXO2HYczZ86o3ijO/NwmARIggdhMwNs86Ov33tvvOZ5nW7dur6HzsJArlLLwtuvevYt62cVmJmxb9BHA8+WgQR/ou0D79q31WXPNmvW6zlObNq2iryKWRAIuBEoVLyjTv1givx85IRkzpJfla7dJvtzZJXXKMIvbdZv3mLAaN6R6xZKSyljxB5vFfddt2SPZsmZUy9ttu36Wi5euypNPhL3XlSiSTxYuWSdrN++SMs8UkmWrt5p34YRSKP9dD1JnE+rUKir4YyIBEoh7BK4aLyEr7A5kSX+fvyR/G8VgwoTxJcjIu7C9bNUWKV+6qGTKECy+5gco20oWKyCrN+6Sp/M/ZYzObsmWHT9JxTLF3MJBzHzGzXeLhjtJQO650B8hJHLkyK7ow6xMs4XrBixOi/jxkydP0YdeTBqw7v7ww+HhFuvduXO3hkuJ6UWtYO08ZcpHxrJ5oBFyT9e2woK8Zs1qug3vBcQOb9mytbHISarC8SZNnlcLcGTo1KmDCV/0rpQuXVEFYxA0Dh9+d/HNRo3qm7ApPUzc9uImLvhE9QpAuJABAwabhXTH6zVCoNe+fRutLzr+QdD68stNzcvla2qhC75Nm75gFgn7SovH9cArAYsXwzIbgvnt23caQV9nE3ZlkbEMzqYhOrDIHLw2EIYGwkIsKgoBpD8JXKtUqWzqbS6FCxcyQtNpbk9bvXqt5M6dU7p06awKIFjJIRxJx45vGEXF92pljBNbtWqhi5AeP35SvQ0GDOhrYuPm1zL9rcttA1x29urVXcMd1arVQPs4W7asZqyOU2G+S1b7KwSs33+/zIyBSsoOIXgqVqxgH/e14WsMoTwoRWDVb6VKlSpoGB4IDqyEsCpR6TOrnJ49u+tivAvM2gRYWwFM5s//2jrs87Nnz27SrVtPM3ZeMvdMEo0r/9JLTVW55u3kQO8VKJO83UuwTgcf3AdTp04KN7842zFs2BBjxf+OOV7OKHiSGO+kXkZwvlizIOzCkCEDzYLcb+m1YC0KeAzA+wIpuphDubBy5Sr904Lv/EP9mzZF9MZw5nFuYy0GLLzcv/8g3Q1PKSxajQTl3syZn6i31dSpn2p4q3Llygr6y0rVq1dTZUC5cpV1zQgoZ63QQVYe10/MH/DkqFattush49X0nc7vEQ5wBwmQAAnEUgLe5kFfv/fefs+LFStiFPWDdX6GkQCMHl55pYUaNMRSFGxWDBCAocHMmVP1OatatToanhEerm3atDLPGq/FQI0skgTCCBQukEsqlzstY8zivLdCb0v2Jx6Xdi3q23h+PvSHWV/vqgr9sbNj6+fls3nfS+/Bk/R9DNbwTRpUlry5suk5UAy0bV5PPl+wXOZ9s0pSpwqSDq0amHfGey5+0PbwHwmQQMwR+G7FRlm9fpddwefzl+t2vjzZ5I22TeSyke+t37LXKP2eUqG/P/NDvRpl5JwJrdx78GQ1vHumaD6pXLa4XQc3SIAE/CPwiBGq/+dP1hNnLkjmx1L7kzXa8pw9e06F3hA8x4YE4RXC11iW8s42IQwIFjpFGCJ3CcevX78miAXrLmGRTmesbORBfbh2K6yQu/Oisg9twuKyKVKE59ulSw+1THfGDYUlNhQXAwb0M+sA1LSrxfA5f/6CLuJr7wxgA+FxoMnFn7uEOps3b2YUDnfXcti7d59av0HYCaFniRJljMC/h0BhBKGrpz7wVZe7+j3tQ38h/E8gYxP9CQtBZ9x8T+W72+9rDLk7x92+qPYZysT1QxANz5XIJiggkFzHn6/yInOveLuX0I/w1vA0Bq32YD7Ci7cV2sbab33ieOrUqdxarkcHc6ue6PhEOC9wT5DA/YsX5jJYrMLTwV26ZhYIx/1kedG4y8N9JEACJPAgE/A2D/r6vff1e445OigoZYTnwgeZJ68tIgE8J2GsBAeni3iQe0ggkgR8vdPj+e76jVBJZkJr+JOwAPANk99bnO3LZrHfFHe8YP0pMy7k8cUxLlwD20gCgRKIiXHva35AaLB48cz6kB7eWwO9htiQPyY4xobrYhtiJwH3Ep9Y0tbY9pALS1hPCcIxTwIynOPruKvAH+d4qw/Ho5rC2hvxgQ6L5Hbu3NWE/WgvefPmUSH1tm07NBxN5cp3F1tG/RCUpk3rPjajP+3zpdBo1aqlen0cPPirxs2HoHndug26ICgE/s6EtngS+COfr7qcZfnaRn8FIvBHeVHtT19jyFebreNR7TOUg+uPisAfZQQq7Mc5SJG5V7yxT5Ys4gJlYTWF/+9rPvJ2PDqYh29N1L55Uj5apfoS5jtDlFnn8JMESIAEHiYC3uZBb785YOTr99zXHP0wcX6YrxXPSZF9VnqYufHao0YA70v+CvxRUwKztlOCZPG9VvqgCfy9XiwPkgAJBETA1/yQ2IQFYyIBEog8gVht6R/5y+KZUSUAy2SEYoKwHZbV2bM/Yce1j2rZgZ5/69YtwQKpv/32u1pk582bWxCyx0pYSBahWtKnD7Z28ZMESIAESIAESIAESIAESIAESMBB4ORf/0jG9Cl9erg6TuGmCwG8J/8vxKxL92gqlyP8SgIPNgHOH1HvX84fUWfIEgIjQKF/YLyYmwRIgARIgARIgARIgARIgARIgATiHIFzF64ILGdT/H97dwIv1fz/cfxDt9u+qYRKxc+WSGUp0U6LsiZ+UahEdvGzVBIRIklRVEiWZF8ipM1S+ZMkSZIoa7TvC//v+5szzb135t47d+Z2Z+p1Ho9778yZc77ne57nzLkzn+/3+znF01Ou7slS4XUbtphSjpQvWyJZqkQ9ENglAlw/4mfm+hG/ISXEJrB3bIuzNAIIIIAAAggggAACCCCAAAIIpJpAqRJFbfW6jabAk3qcMuVeQF5yk58cmRDY0wS4fuT9iHP9yLsda8YnQE//+PxYGwEEEEAAAQQQQAABBBBAAIGUENiydbutXb/JNm3ZRuA/hiOme3QVTU/zAf/0wtnfxyCGYlkUgZQS4PqRt8PF9SNvbqwVv0BS38g3/t2jBAQQQAABBBBAAAEEEEAAAQQQkIAC1qSm4VxAAIG8CHD9yIsa6yBQcAKk9yk4e7aMAAIIIIAAAggggAACCCCAAAIIIIAAAggggEBCBQj6J5STwhBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQKDgBgv4FZ8+WEUAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBIqABB/4RyUhgCCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAgUnQNC/4OzZMgIIIIAAAggggAACCCCAAAIIIIAAAggggAACCRUg6J9QTgpDAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQKDgBAj6F5w9W0YAAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAIKECBP0TyklhCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAggUnABB/4KzZ8sIIIAAAggggAACCCCAAAIIIIAAAggggAACCCRUgKB/QjkpDAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQACBghMg6F9w9mwZAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAIGEChD0TygnhSGAAAIIIIAAAggggAACCCCAAAIIIIAAAgggUHACBP0Lzp4tI4AAAggggAACCCCAAAIIIIAAAggggAACCCCQUAGC/gnlpDAEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBApOgKB/wdmzZQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEipA0D+hnBSGAAIIIIAAAggggAACCCCAAAIIIIAAAggggEDBCaTFsullv6+KZXGWRQABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAgV0oEFPQv0qlsruwamwKAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEYhEgvU8sWiyLAAIIIIAAAggggAACCCCAAAIIIIAAAggggEASCxD0T+KDQ9UQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEIhFgKB/LFosiwACCCCAAAIIIIAAAggggAACCCCAAAIIIIBAEgsQ9E/ig0PVEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBCIRYCgfyxaLIsAAggggAACCCCAAAIIIIAAAggggAACCCCAQBILEPRP4oND1RBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQiEWAoH8sWiyLAAIIIIAAAggggAACCCCAAAIIIIAAAggggEASCxD0T+KDQ9UQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEIhFgKB/LFosiwACCCCAAAIIIIAAAggggAACCCCAAAIIIIBAEgsQ9E/ig0PVEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBCIRYCgfyxaLIsAAggggAACCCCAAAIIIIAAAggggAACCCCAQBILEPRP4oND1RBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQiEWAoH8sWiyLAAIIIIAAAggggAACCCCAAAIIIIAAAggggEASCxD0T+KDQ9UQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEEIhFgKB/LFosiwACCCCAAAIIIIAAAggggAACCCCAAAIIIIBAEgsQ9E/ig0PVEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBCIRYCgfyxaLIsAAggggAACCCCAAAIIIIAAAggggAACCCCAQBILpCVx3agaAggggAACCCCAAAIIIIAAAggkSGDL1u22dv0m27Rlm/3zzz8JKnX3L2avvfayoulpVqpEUUsvXGj332H2EIEIAlw/IqDkYhbXj1wgsUi+CBD0zxdWCkUAAQQQQAABBBBAAAEEEEAgeQQUsFu+cp2VKVnM9ilT3BSIYsqdgBpI1m/c6v0qlitJ4D93bCy1Gwlw/cj7weT6kXc71oxPgPQ+8fmxNgIIIIAAAggggAACCCCAAAJJL6Ae/gr4lyyeTsA/xqOlBhK5yU+OTAjsaQJcP/J+xLl+5N2ONeMTKLCg/8qVq0I1D38czNy2bZvNn7/Aliz5ybZv/zuYneXvjz/+ZD/9tDTLfGYgEAisWLHS9MOUvwJffTXP3n//g/zdSITSX331jaS8BqheS5b8GKHGGWdt2LDBZLdmzdqML/z7bO3adbZ+/Xr/TNfCn3/+JepPxALyOFPb0jV43bp1eSyB1RBAAIHdS2DhwkX21lvv7F47xd4kpYB6BOo70DffLLDNmzcnZR2pVGoKKKVPiWKFU7PySVJr+cmRCYE9TYDrR/xHnOtH/IaUEJtAgQX9L7nkUl9TBbyuvPK6DLV+6qlnrE6d+tajx9V29tnn2fHHN7TXXnszwzKTJk2x1q3PsPbt/2tt255lrVqdbt99932GZVL5ydSp023jxuTvQaAA5Ny583YJdV62pS9MzZu3tj597tglddyTN/L++5PtscdG50iQ6HN7wICBLmj+dY7b3dULqF5ffPFl1M3q2nfppVda3boN7MILu9hxxzV018LrM7zvV61a5Za5wl588VVfzooVf1nTpi2j/iQqL+vTTz9rDRo0tu7dr/D1Gjx4KDlfox5JXkAAgT1FYNasT23QoIf2lN1lPwtIYNas/7OGDZvaued2tG7drrBjjjneBg580NQhigmBeAX0WZGUPvEpyi9Rn7njqwlrI7BrBbh+xO/N9SN+Q0qITaBAcvqvXr3GSpcu7WuqoGyNGtX9Y/364IOp9uCDD9moUcPthBOO8/MfeeQxu/nm3i4IdYJVqrSv7+V600297H//u959ID7btm7dZnfeOcCuvfYGe/vt10JlpfKDa6+90e9L5coHJPVuTJz4nm9sOfroWvlez1i3tWXLFrvuuhusUKECa9vKd5NU3ECqnNv5bXvLLbfZjz/+aC+88Izp/TNnzly75JLuNmzYcH9tu/DCS3xPe/Xyb9XqVF+dihUr2sKFX2WpWteul1uRIkUT8iVu9uw57hr8sD3xxAjXIFHH9zK84IJL7OCDD7LTTz8ty7aZgQACCCCAAAKJEVBjvz4LXH/9Na7R/xJf6MyZn7p5l9oRRxxu7dq1ScyGKAWBCAJLlv5qMz/72v74a4XVOuxga3pSPffZMsKC/8769Iv59uW8RS7P/UarVmU/a9WsvhUrWiS0wsrVa+3jWV/aoiU/W9UD9rXTTmloRYukh17nAQII7D4Csb7f163faDM//9q+WfiDlSpZwpo0rGPVq+7vQb5ZuMSmz5wTEafFycfawTWqRHyNmQggkFWgQKKhSnlRo0YNX5sffliSIei/aNEiO+usM0MBfy3Uvv1ZvjVdw6o1PfTQMKtd+yj77387WFpamhUrVtT15L7Z9Ya5xPWS3eiXSdQv9bb//PMvfIohBeVmzJiVoehFi763yZOnmT6kZ57++GO5TZkyzaZP/8j+/POvzC/7dB56XT3lt2/f7l9XGho1fGg/vvzyK1uw4Nss64XP0Hpa7p133rN5877OkgpJvYI0NFgjI4Ky1GP+++8Xh4pRUFF1/Prrb+zvv3emUtq579t9GVomPE2Otvf553P8vv3f/31uSkOS3bR8+Z/28ccz7MMPP/H7rvQheq5JVipP02efzfam4elOYt2Wyrn33gdcI9F+duqpp+hplkmNT/L/9tuFue6tEe2Y5mSljetYKY3LpEmTMzgqRZV+gknLzZ79RfDU/1206Hvf2BXMjHbMVD8dbx33adM+zHH0i8qdOPF90/FTz/NgUjk6H1SXTz/9zNTrLPPIE7X0Byl9ZJnTlN25rbJUb40CiFRWTq/ntG2V/csvv2ZYTMbh71uZ6ou1zs/M+6oVly9f7t9HS5cuy1BOTk9+//0Pb6ztBe8vuc6Z86UbzdTdX8vU4l+nTm13rrbwx0JlPvPMk+48mGEVK1bIdhPvvjvJLTfH+vXrnWG5aOeIFtL2o103Ro58wpo1a+ID/lp2R5DhNBsz5hk9DU3Rzp3QAjxAAAEEdlMBXcv1f1Ep7fS/IfOU3fUxv/7XZK4Dz1NTQJ+9jjyypnXpclFoB+rXP96qVKniGv2/C83jAQKJFpj/7Q82bPRLVqJ4UTu29hE2a/bXNv71SVE3884HM+2NiR9anaMOsXYumL9i1Rq7b+gz7jvIv99p3fP7hz5rK1ets4bHHW1/rlhjg4Y/b9vcZ1AmBBDYvQT0/o/l/b5i1VobOGys/bTsN2t4/NG2f6V9bPSzb9r3P+z4nl2mTCk7/JBqGX5KlShu3y76yQqnk55s9zp72Jv8FtilPf2Vk7Jjx4t9oFA7Ns8FeRU01PTZZ5/biBFD7bLLuvnnwS8FIgcNGmL77VfJNQQc62creN26dUsfxJs8earr4VrEpaA41qUCOiNYLWF/ly5d6hoXOlvnzhfYK6+8bieeWN+POFBQsHPnrj7Xthowbr5ZIw96WocO5/htK+drv379XWqi431gUUHHRx55yK+vBZ599gXr33+A1ax5hAuWr/UjGLT/3323yEaPfsqXMW7ceNcD+Cg7/PDD/PPMv9QwcPHF3V0AfY0PzM2YMdN9UTjSRo58xPf4VXD/ssuudEHDilar1pGusWSoDwbrOPTt28v33J0wYaLdfvudduyx9ez33393oya22nPPPe1GYpSyYN9btGhuy5Yts79crw/l93788Ud8o8y4cS+5wOGXrid9IbfNJ+3GG6+1UqUOyVxN/1yvP/30Mz6oqcaBW27p7Rpriln16tXcEOYG9u6777uexWP8vmq7CvyuWrXarTPaB0Nj2ZY2+N57k1zjyRR7442X3JDowVnqNHbsc/bAAw9ZvXp1TA1P5cqV9UHW4sWLZ1k2mJHdMc3JSq46VqtXr7bDDjvUmd/lnnfyvbg++WSmvfzya/bSS8/5TanRo1OnLjZhwmt2yCEH+3lK8XLzzTeaRn5kd8zk+NJLr1qJEiVs8eLFrvwuoTKC/Qj+3nXXvW40yUSrX/8E16P8G39uKNCs91pwPHTuKLih81KjbPT6vvtW9Pllzz+/ky1atNifC3qPVqlSOSg64t9o57YC7+ef39lvR9v+4ouedvfdd4R6lef0esSNZZrZu/ftLiVOE7v66h6hVzp16mpDhjxgLVo0840uej/rfCxVqpT17Pk/dz0a5s8PraCRRAqu1617jL9u6XozcODdobKiPdA5OGLESG+qAJGuHyNHPurfM9OnZ/wipUC8GqAOOmhHg2i0MsPnazTLgAH3+XNJxyWYsjtHcrpuqEHwoosuDIryf9Ug8dJLr/jGMTVQZHfuZFiRJwgggMBuJrDV/T/X6Cpds/X5QR0Uhg590Bo1OsnvaXbXRzXw58f/mt2MeI/eHX0m1k8wqYPMuHEv2q+//hYa9Re8xl8EEikwYdInVq+2G03Scse1rIrrmX/PQ2Os2cnHWcXyZbJsavlfK61MmZJ27DFH+NeWr1htc776zra77w1pVsg+nPmlFSla2Dp1aOVfr1f7MLux3zD7dPZ8O/G4o7KUxwwEEEhdgVjf75+6RsXiLhbUpWNb27Bxsx1T61Br2bR+COCASuVNP8GkRoJ3Js2wq7u2twMrVwpm8xcBBHIhsEuD/grOv/zy8z51hIKtjRuf7IJrN9tVV12eJdClXv1XXXWdDzwrrcSbb75s6enp7kvW3/5LlgLaF198qQ9Wq1dy3753uuDXnW6UwOm52O3YF1Eg8LPPPra9994xOOK++x6wsmXL2vjxz/gAuxoi2rfvaCef3ND2338/H3Du0+dWO/PMdn5j1133Px/oV9Bv4cLvXNBsgMt/PswbqFe2cnrrxp+dOnV0AeFebvjuOXbPPf19kDdabZXHvKgbQjlmzHj/d/HiH/y9DVS+AsvPPz/e1W1ve/LJx30RCuQ1bnyKPfroEL9dGfbqdZs99dQoH1jXQldf3dPuv3+wa5DoG9ps48Yn2XnntfdB2Ysu6ubKe9oHeu+663aXg3yVC5KWdL3q+4eWz/xADQWDBz/sGh3u90F/vX733ff53smjRg0PLa76dOx4vq+fTHr1ut01DvRxwdY3nVfutqXCVM5tt91hw4cPdR9Gs35IVWBVowDGjh3tezMrqK2g8733DnLB3dtC9cn8QAHcaMc0WDaa1Zw5c13P+flupMg0PzJF58sTTzztg6jNmzd1273bj5ioUKG8qbe7juvkyVN8wF7HVef4ySef6Pctp2Om/Xv88UddAKJhUK0sf3VM1Dt8zJjRfht6XzVu3MI3lnTufIFfXl8wdXz0/lNDTaNGLVyDwztuiHln38ijHu/Tpr1v++xTzjdstWlzph1wQPR0VErXFenc7tu3v28wUDBcAWWNULjiimvde7uuK29/997O/vUsO5eHGW+++bZVq3ag8xjl13799bd8Pn5dp95++10/OmPChFf8e152p5/e3t/MsW3b1tluTTcZf+utV6xw4cLufb/IrXeOa4iakOU6pZFAffr08zf+vf/+AdmWGf6i7nWi+uiYBFNO7+vsrhs61jquagQLn8qWLeMbBDVao4gblp3TuRO+Lo8RQACB3UlA/4979brZ2rRp6RvLlartjjvudv8n3vYdQbK7PubX/5rdyZd92Slw1lkdXAeOH9x3j0Iu8P+069izI7i6cwkeIZA4geV/rnSBt52dt8qXK+O+p7iRrq7TV6Sgf4vGx9nDj4+3e4eONS07b8H3rsGgoRX5txfu8j9XWYV9dn4P03focmVL2h9uO5Gmt96ebaOemOoaUhM7aj/StsLnvfLSteFPszzWd5NiRdMt3X2WZ0IAgcgCsb7ff/vjL9dJsaiNHPuGff7lAhf7SHfpferama0bRdzAuNfes+oHHmA1qkWONUxdNtPeWvyebdy+M3NBxIJymHl3vT45LBHby1w/YvNi6fwR2KVB/02bNrsewpt8Wgv1rlWv57lzv/I9a9X7XI0CwXTAAfvZrbf+z376aZn7oDveB/gVoFQqH/Wumjlzlru55XM+4Kh1hg8f6QO9p53WyjcOBOUk6q9GEQQBf5X5ySczXeDuDJeSZGf6HQU/NXJBQf/Bgwf6AK3Sx6iH/Nat2+y3337z1VEqlQoVKvjAu2akpaX5AHSQ+sMvlOmXvmRu3brVz1UPeW3r+OOPdcH64T5NhwK0GhWhsn777Xcf9JenXP9xn9h0wdHjv//eHjLTTUYVFNdy8+cv8GUrlYd6f4dPapzRpP1v1qyJq+uOHumal3nSMV2/fkNomwrapqUVdkHPtAwpU7TMPvvsk2F11fGcc870dVWQtF2701yA9C2/X5F64EfalhoL1MDSteslvld2hg38+0T+6tGtfOWatF/t259lTz011j9XT+iVK1f5fdAM9XCXa3bH1K/ofkWzOvTQ/3j7Bx8c4nuw16xZM9RTXD20NUJDwW7tv4L+3bt382meLrusm5v/kW9kUe/9KVOm53jMVN/wgH8kp5IlS7qRK+N8Sh31YNcyOhd07gRTlSqVfcBfz9Wwo6B9cLPsuXPnuV7rDULnkhrAGjY80TfIaXk1ImjkiM49TQoaq/6RJqXUufPOvv6463UZKuis9DM6f3J6PbzMWLYbvp5y6mukiRq0mroRAWec0Tb0slJ61apVy40s+s3/6IXDDz/cNQrMcTcRb+3tMp/zwcotW57iA/56rnPgiCMO8wHzoHFS9dUImGHDhrtGh2r+mqblcjPJdvTop9w5c5YfmROsk9P7OrvrhkYZ6Dr09987jltQZvBc75XcnDvBevxFAAEEdjcBfT7RtV2TPhu0adPKf1b5888//cjK7P63xvO/ZndzZH9yFrjhhut8D399TuvS5XL3OXWkGyF8eM4rsgQCeRBQ2h19Xwum9H8fb9q0JZiV4e9GN+p9b9e5bMOGje6vu7GtyxC7fsPm0DLbtm8LfQYOZhZ23wmjlVcQAf+gXtn91eftjc6AoH92Sry2pwvE+n5f5UZJfr/kF2t7yol2/tktTOnFxox726pW3tfqHZ3x/9zPvy63r77+3m69bmfau8zeiQj4Zy4zEc+5fiRCkTLiFdj5nz3eknKx/qRJk+21197wQTz1/FYAST1hb731NtfTuoNLs9E0VIoCS02bNvbPO3Q42wUYm7qe8uNcDuxL/T0AFLBV4DuYTjmlme9NruD1McccHcxO2F+NMggmvXmXLfvZ54OfN29+MNuOOuoot0+FfKCzT587XK/umS4o2Mal9tgvw81kta6ChuGTvkRmN/XocY0PoiowrqCkeqRr20rfc9xxx/r0PWXK7Lg5clBO584dfc78Fi3a+O3NmTPHB8Nr1TrSL7J06TIfUNeNksOnQw/d2ctD87XNYJKD9j/aNHTocJe//D3/crly5fwIDfVav/PO261fv7v8F+O1a9f5QOmwYQ9lKKZ8+X0yHNNq1ar6banRJFLQP9K2dO8CNbyUcDnf1DCkSWll1BjQpctlPt2N/MNToWiZ8uXL+xRGeqyGmgEDBuqh3/exY5/wvcCzO6Z+4X+XDx6HWymgPn78sy5IO8bde6KH2y+za665wo3w+K9fXI1g2q4Csuq5rftTjBr1pO/9P336hz4FjRbMzTELP1e1TiQnpSPQSBk1+Jx00omuEap8huOs9cKPu56rXDW4aVJAv1GjHY1Bfob7pfejUh1o0usdOuwYMaByeva8Nkvvdi2nhiql78l8PFSfYF+ze11lhE+53W74OnqstAwPPHCvS1/0nL+O6D3bv//tvqFDqZvUez78faJ9UuojTZF8/Qvul/YjfDrkkEN8Oi/NUyNot26X+158t93Wyzc0ZDYPXzfzY6ULkrfSbYVPgVt4ffV68L7O7rqh65CO44oVK8KLdI1gK/3xV2NMbs6dDCvzBAEEENiNBNTIXajQzltiBQ21ujbqhurZ/W+N53/NbkTIruRSQJ/PNJ177tk+LdTAgYN84D+Xq7MYAjEJlC5VwnXQ2hm03+A+p2oqXSpr6lN9jxn1zJt25OEH2YXtW/rldBPg+x4ea4ccVNlqHX6wW69Ell79G12ZkcrzBfALAQRSViDW93uFfcraXy4lWJDS54S6R9qUj2fbwkVLswT935v6qR12yIGk9UnZs4OKF7TALg36t3W9YjUc+pxzzvcpZ9R7vXfvfj4HfQBx0029fWBx0KB7g1k+97sCwn/9teNmuOqNvnjxD6HX9UA3y9RUufL+/m9+/lJgTl/yTj/9tFDQVttbvvxP1wu2hA8yv/jiy+7muJN8Lm+9psClAoeaFHxT3nX1qFXDhya9pudVq1bxzzP/evnl5zPP8rnCmzRp7FLl9POvaX0F1oNJKWU0OuD22/u4AGV5n0IpfDSF6qFGikceGRys4nvjr1u3NvQ81gd9+tzi0pTckmE11UtD2jt16mhNmpzsjlFl33s+w0LuiVKcBD3O9Zpy26u+ymMfaYq0Ld3/QAHU8Gnz5i0+0Nq8eTM/CkP7rZz/4dOPP/4Y6tWuXnv6CZ8WLvzO9cKOfkzDl430WA0dSn2j1C1qNNHNn6+44hpr3rypr5P+PvbYKH9TQB1TNZSoJ71GXcjh7rvv8MXm5ZhFcnr99R1pYdQjMZgyj/AI5kf6W6lSJX8/h/DXgveg5qmH/kcfTQ5/OeJjNebo+KrxT/nyNel80Qif//znYN/Yk93rmQuNtl2d55s2bQotrt5JGvUSTGpYatDgBDeSpbF/zwwZ8ohPt/P++xP8qBml91LO5mDSPSfM3DceN0Xy9S+4X+Emmqf3uRp2NA0ZMszdE+F7l/JsXNRz3C8Y5deECRP9PT+Ulih8yukcGTFipHsfRr9uqPFy5sz/8/cxCcr99NPP/Lb0PN5zJyiTvwgggEAqCqgRVPdTCRrY1ZFA9zY68MCqPve6Gu6j/W+N539NKlpR59gFXnjhJRfYH+tSfu5I3RmUULVqVT86OnjOXwQSLbBvhXL2869/hor99bflrgOQ68BSfmcnu+DFNevWuxv0rrWjjjgomGXVq+5vpUoWtx+X/u6D/irvy3nf+Y5OKmfzlq0+yKf5kaZuXZoUSHqfSHUJn6fv/Urvw4QAAtEFYn2/77dveXd9WJSlwPBOFXpR+f5nz/3WLjo/+5S6bQ86NSHpfbJUKM4ZXD/iBGT1hAjs0qC/aqw0NPvvvyOIq8D9QQdVz7Ajynl/0029fI75du3auB7a213v2+d9z3r1htZ03XVXuV7DHdyH4mfcTXbP9cHigQMfdDfdrBvqfZuh0Hx40rp1K59aQ6MRFJScPv0jNwrhGtfL/Q3/5U+bXLLkRx/0/+WXX32O/6AaSpOigOOIEaNcLu5Ovsdv166Xu3z6V/igf5AGRYHFaAFvlZWWluZ7p6v3tRoPxo59PkPvbKUcmT9/vutR3tP1ZN/H92ZXL7PzzjvHOylnunr2qh6XXnqJD4peddX1LiBfKdsc/cF+6K961CtQn92kIPfy5ctdj+SP/Q1rNSJBgcnTT2/rg6zBuqrLgAH3u4aL3j7NzPjxL/t7JAQNI7nZVvXqB5p+wqdFixa54Otyu+CC8/xsbeeuu+51DU9jXWCzo78htFK7qFEi2qQv9JqiHdNo6wXzP/roE5fOZ5Dv7V+xYgXXs72CO2buQ2Sxon4R3bBXx2j48Med/d1+nka+3HPPQD+yRcFsTYk4ZiqnUKE033s7aGSZ6VLsKAB95JE19XKOU6tWp7jj1N+d7++bRtlMnfqhT3cT9H6PVkCkc1vv60cffczdUPh43zNePdSVwqpevR2NADm9rgaSzI2Ambd/2GGH+psTd+x4nn9Pjh37nAvY7EwnpvQ6Sm2kG/sqkKMe7aqDplNPbeFGiXT3o2YaNmzgA/caxXDjjddHHL0Qvu0PPpjiGxPUoKEbgc+e/YW74ff1fpGPP57hGjrq+tRfS5b8FFpNH3aiNf6FFnIPJk36wF0/Lgqf5R/ndI7kdN3o0qWzK7e7v/dAy5YtXOPNDN/4NHjw/b78eM+dLBVmBgIIIJBCAsWLF/P3purRo7vv0KHRXied1NB/nsrp+phf/2tSiI+q5iCgz0L9+9/jP6d2797Ffy5SascJ7p5KXbtenMPavIxA3gUaHHuUPfn8BJdyY5kdsF9Fe3fqLKt5WA0rW7qkL3TaJ1/YJpcqVj1zy7he/BXczX2nzfjC59kuUbyozfr8a1uzdoMdVG3H9/zj6tS0VydMs6mffG4nHV/bJk6e6T5jF7baR2YcUR7UuG2buqYfJgQQSD2BnN7vuhHvxA9mWGOXt7/yfhXsuGNq2ruTZ7nrw2xr3KCufbPwB/vJNRi2blY/w87PnrvA9i60V9TrRrBwkyr1TT9MCCCQVWCXB/2XLl3melTX8DVRr9caNar7x8Ev3fhWweoRIx73H3oVMFb+9QcfHOiDglpOAbEhQwbZww8/aoMGPeSDpw0a1HdB1QFBMfn+97LLuvo0LBq1oKC7AsnqxR0E6y644HyfTkY9v1T/888/1/cAU8UUwNWNVnWz2dGjn/R1VXqj1q1P9Y/1eosWzd06F7pURbVdzu/Rfn7mX5df3s03NNSv39j3nFe6mCA4rFzhSrNz3nnn+nsPKI2KGh+Us1wpQTSSQsH3MWNGukaW3i6VzBMu5/8Wn7Ll5ptvyLypqM91r4OePW9yvYCPdT3VH/EBzswLK4e+RhzoxsXKDa/GDPUc7tHjat9IUqNGdb+KUrwcfPBB7stzM98QokDpPffc6V/Tr9xsK7RwNg/UkDJ8+MMuaH2Xu7nwUD+aQA1M3bt3jbqW6pXdMY264r8vnHpqc9czfq7LA9zO519XGoDevW/xN4YN1lVv/+eee8H18D/Bz1KDUq9efd1okqbBIgk5ZirstNNa2TvvTHR5+Jv592CTJo182qjQhnJ4cMYZ7VyD0jf+2Ovc13l//fXX+Aa67FaNdG7fcsuN/kbBuhGwevmr0WbEiIf9PQZUVk6v670zbNij/j2o90SkqWfPa1zj1w1uH1v6ewvo3gk1ax4RWvSqq3q4NGN9nUdTX45GmATXk3r16rjz8C43Yqa/b+BSD8+LLurkG61CBUR5cM01V7og/60uMLTab1c3gg7Sj61Zs8YH7hW8D5/UcPLxx9mPktB7WD1Gg9ER4evn9L7O7rqhchRw0E3E1TCmuus9e+utN4XSr8V77oTXlccIIIBAqgm0bHmq7yTRqFFzf/+aOnVq23337RhlmdP1Mb/+16SaIfWNLqDRe2PGjLK+fe90nQ7a+tGhpUuX8gH/K6+8LPqKvIJAnALH1DrUmjf6zR5yN+fdtnW7u2Hm/nZppzNCpX69cLFL8bghlI7jii7n2NPj37Fedw33Hd7UG77Dmc3tiEOr+3XUMNDtwtPt2ZfftfGvfWBly5SyHhef6T5n7/LwQ2gfeIAAAvkjkNP7fZ2L702fMccF7//jg/5lSuv60M5efHOKvfLWNNcgmGZntD45S3B/3oLFdnC1ylY4jetG/hw5St0TBPZyQfUdOSpy2Ntlv6+yKpXK5rBUYl9WuhcF3xR0ijYpgKwe4Oq9WhCT+HTT1/D7CwT1UM7ubdu2+htfBvMy/1X9lRIo6Eke/roCoBoSpJ/sphUrVvqeyeHLKSioAPO4cU+HblirMh57bLTrbf+qS2/zVoYi169f73t/q9d0XiY1MmQejhWUc/31N/le5boBWTDppsIKsPbrd5u/Gap6Xqu3/ZQp7/oUQxoJEfQKD9YJ/ma3rWCZ3P6Vv86vYDRBTuvl5phmV4bqrnzpFVyu9/Djld060V6L95ipXO2/ei0qcJ+XSY05asDQKIVYpkjntmzUOBXt/Z7d6zqf9B7K6Tqguso92jZ0fDdt2pihMSZ8v5Smq1Sp0lHP9fBlg8e6Rug9GqtRsH48f7M7RyJdNzJvSyN0KlSoEPFcjffcybwtniOAAAKpJLBx40bfUB3ps0pO18f8+F+TSnbUNXcCShWlc0WfGZkQSJRATt/p9Rl90+atVrxY7r4T6gbAm93y6u0fbVrnbvZb0n3f2J2mnBx3p31lXxAIBHJz3sf6flcKn9xeb4J6pPrf3Dim+j5S/+QRSOqgf/IwpV5N9IHtqqt6upv9zvO54TXiQCMrpk//0I0wuNWnLNlVe6XUMVdf3dPdbLim6X4MCjDrJqRFiqS7Ht3DfIqb8KD/rqoX20EAAQQQQAABBBBAAAEE9hQBgk2JOdI4JsaRUlJLgPM+MccLx8Q4UkruBAj6584pZZdSz+kFCxaa0iqVK1fO9fqvne3Ig/zaUfV2Vh0WLPjWD4evUaOa6aa7waQbnup+D0Hqk2A+fxFAAAEEEEAAAQQQQAABBOIX+PmP1XZAxdIRR3HGX/qeUYK+1/6y3N17b98ye8YOs5cI/CvA9SP+U4HrR/yGlBCbAEH/2LxYGgEEEEAAAQQQQAABBBBAAIGUE/hr1Xor4m6oW7J4esrVPVkqvG7DFtu8ZauVL1siWapEPRDYJQJcP+Jn5voRvyElxCawd2yLszQCCCCAAAIIIIAAAggggAACCKSaQKkSRW31uo2mwJN6nDLlXkBecpOfHJkQ2NMEuH7k/Yhz/ci7HWvGJ0BP//j8WBsBBBBAAAEEEEAAAQQQQACBlBDYsnW7rV2/yTZt2UbgP4Yjttdee1nR9DQf8E8vXCiGNVkUgd1HgOtH3o4l14+8ubFW/AJp8RdBCQgggAACCCCAAAIIIIAAAgggkOwCCliTmibZjxL1QyA5Bbh+JOdxoVYIRBMgvU80GeYjgAACCCCAAAIIIIAAAggggAACCCCAAAIIIJBiAgT9U+yAUV0EEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBKIJEPSPJsN8BBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQRSTICgf4odMKqLAAIIIIAAAggggAACCCCAAAIIIIAAAggggEA0AYL+0WSYjwACCCCAAAIIIIAAAggggAACCCCAAAIIIIBAigkQ9E+xA0Z1EUAAAQQQQAABBBBAAAEEEEAAAQQQQAABBBCIJkDQP5oM8xFAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQSDEBgv4pdsCoLgIIIIAAAggggAACCCCAAAIIIIAAAggggAAC0QQI+keTYT4CCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAikmEFPQ/58U2zmqiwACCCCAAAIIIIAAAggggAACCCCAAAIIIIDAniSQ66B/WqG9bdu27XuSDfuKAAIIIIAAAggggAACCCCAAAIIIIAAAggggEBKCeQ66F8kvbBt2rwtpXaOyiKAAAIIIIAAAggggAACCCCAAAIIIIAAAgggsCcJ5DroX6JYuq3buNlI8bMnnR7sKwIIIIAAAggggAACCCCAAAIIIIAAAggggEAqCeQ66J9euJAVdb39V63ZmEr7R10RQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEENhjBHId9JdIudLFbPv27bbSBf7p8b/HnCPsKAIIIIAAAggggAACCCCAAAIIIIAAAggggECKCOz1j5tirauC/pu2bLWSxYpY0SJplpZWyPaKtRCWRwABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAgYQK5Cnorxps2brd1m/cYptd8H/b9r8TWikKQwABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAgdgF8hz0j31TrIEAAggggAACCCCAAAIIIIAAAggggAACCCCAAAL5KRBTTv/8rAhlI4AAAggggAACCCCAAAIIIIAAAggggAACCCCAQHwCBP3j82NtBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQSSRoCgf9IcCiqCAAIIIIAAAggggAACCCCAAAIIIIAAAggggEB8AgT94/NjbQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEkkaAoH/SHAoqggACCCCAAAIIIIAAAggggAACCCCAAAIIIIBAfAIE/ePzY20EEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBJJGgKB/0hwKKoIAAggggAACCCCAAAIIIIAAAggggAACCCCAQHwCBP3j82NtBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQSSRuD/AWxXftx7Cf01AAAAAElFTkSuQmCC" + } + }, + "cell_type": "markdown", + "id": "47c38cd3-2c31-48c4-8281-bd9e1f7b2830", + "metadata": {}, + "source": [ + "We can see the results benchmarked against `GPT-4o` and `Llama-3-70b` using `Custom` agent (as shown here) and ReAct.\n", + "\n", + "![Screenshot 2024-06-24 at 4.14.04 PM.png](attachment:80e86604-7734-4aeb-a200-d1413870c3cb.png)\n", + "\n", + "The `local custom agent` performs well in terms of tool calling reliability: it follows the expected reasoning traces.\n", + "\n", + "However, the answer accuracy performance lags the larger models with `custom agent` implementations." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/rag/langgraph_self_rag.ipynb b/examples/rag/langgraph_self_rag.ipynb new file mode 100644 index 000000000..4aedf620d --- /dev/null +++ b/examples/rag/langgraph_self_rag.ipynb @@ -0,0 +1,792 @@ +{ + "cells": [ + { + "attachments": { + "15cba0ab-a549-4909-8373-fb761e384eff.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "919fe33c-0149-4f7d-b200-544a18986c9a", + "metadata": {}, + "source": [ + "# Self-RAG\n", + "\n", + "Self-RAG is a strategy for RAG that incorporates self-reflection / self-grading on retrieved documents and generations. \n", + "\n", + "In the [paper](https://arxiv.org/abs/2310.11511), a few decisions are made:\n", + "\n", + "1. Should I retrieve from retriever, `R` -\n", + "\n", + "* Input: `x (question)` OR `x (question)`, `y (generation)`\n", + "* Decides when to retrieve `D` chunks with `R`\n", + "* Output: `yes, no, continue`\n", + "\n", + "2. Are the retrieved passages `D` relevant to the question `x` -\n", + "\n", + "* * Input: (`x (question)`, `d (chunk)`) for `d` in `D`\n", + "* `d` provides useful information to solve `x`\n", + "* Output: `relevant, irrelevant`\n", + "\n", + "3. Are the LLM generation from each chunk in `D` is relevant to the chunk (hallucinations, etc) -\n", + "\n", + "* Input: `x (question)`, `d (chunk)`, `y (generation)` for `d` in `D`\n", + "* All of the verification-worthy statements in `y (generation)` are supported by `d`\n", + "* Output: `{fully supported, partially supported, no support`\n", + "\n", + "4. The LLM generation from each chunk in `D` is a useful response to `x (question)` -\n", + "\n", + "* Input: `x (question)`, `y (generation)` for `d` in `D`\n", + "* `y (generation)` is a useful response to `x (question)`.\n", + "* Output: `{5, 4, 3, 2, 1}`\n", + "\n", + "We will implement some of these ideas from scratch using [LangGraph](https://langchain-ai.github.io/langgraph/).\n", + "\n", + "![Screenshot 2024-04-01 at 12.41.50 PM.png](attachment:15cba0ab-a549-4909-8373-fb761e384eff.png)" + ] + }, + { + "cell_type": "markdown", + "id": "72f3ee57-68ab-4040-bd36-4014e2a23d96", + "metadata": {}, + "source": [ + "## Setup\n", + "\n", + "First let's install our required packages and set our API keys" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a384cc48-0425-4e8f-aafc-cfb8e56025c9", + "metadata": {}, + "outputs": [], + "source": [ + "! pip install -U langchain_community tiktoken langchain-openai langchainhub chromadb langchain langgraph" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "de4ee2a5", + "metadata": {}, + "outputs": [], + "source": [ + "import getpass\n", + "import os\n", + "\n", + "\n", + "def _set_env(key: str):\n", + " if key not in os.environ:\n", + " os.environ[key] = getpass.getpass(f\"{key}:\")\n", + "\n", + "\n", + "_set_env(\"OPENAI_API_KEY\")" + ] + }, + { + "cell_type": "markdown", + "id": "25d16369", + "metadata": {}, + "source": [ + "
\n", + "

Set up LangSmith for LangGraph development

\n", + "

\n", + " Sign up for LangSmith to quickly spot issues and improve the performance of your LangGraph projects. LangSmith lets you use trace data to debug, test, and monitor your LLM apps built with LangGraph — read more about how to get started here. \n", + "

\n", + "
" + ] + }, + { + "cell_type": "markdown", + "id": "c27bebdc-be71-4130-ab9d-42f09f87658b", + "metadata": {}, + "source": [ + "## Retriever\n", + " \n", + "Let's index 3 blog posts." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "565a6d44-2c9f-4fff-b1ec-eea05df9350d", + "metadata": {}, + "outputs": [], + "source": [ + "from langchain.text_splitter import RecursiveCharacterTextSplitter\n", + "from langchain_community.document_loaders import WebBaseLoader\n", + "from langchain_community.vectorstores import Chroma\n", + "from langchain_openai import OpenAIEmbeddings\n", + "\n", + "urls = [\n", + " \"https://lilianweng.github.io/posts/2023-06-23-agent/\",\n", + " \"https://lilianweng.github.io/posts/2023-03-15-prompt-engineering/\",\n", + " \"https://lilianweng.github.io/posts/2023-10-25-adv-attack-llm/\",\n", + "]\n", + "\n", + "docs = [WebBaseLoader(url).load() for url in urls]\n", + "docs_list = [item for sublist in docs for item in sublist]\n", + "\n", + "text_splitter = RecursiveCharacterTextSplitter.from_tiktoken_encoder(\n", + " chunk_size=250, chunk_overlap=0\n", + ")\n", + "doc_splits = text_splitter.split_documents(docs_list)\n", + "\n", + "# Add to vectorDB\n", + "vectorstore = Chroma.from_documents(\n", + " documents=doc_splits,\n", + " collection_name=\"rag-chroma\",\n", + " embedding=OpenAIEmbeddings(),\n", + ")\n", + "retriever = vectorstore.as_retriever()" + ] + }, + { + "cell_type": "markdown", + "id": "29c12f74-53e2-43cc-896f-875d1c5d9d93", + "metadata": {}, + "source": [ + "## LLMs" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "1fafad21-60cc-483e-92a3-6a7edb1838e3", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/rlm/miniforge3/envs/llama2/lib/python3.11/site-packages/langchain_core/_api/deprecation.py:119: LangChainDeprecationWarning: The method `BaseRetriever.get_relevant_documents` was deprecated in langchain-core 0.1.46 and will be removed in 0.3.0. Use invoke instead.\n", + " warn_deprecated(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "binary_score='yes'\n" + ] + } + ], + "source": [ + "### Retrieval Grader\n", + "\n", + "\n", + "from langchain_core.prompts import ChatPromptTemplate\n", + "from langchain_core.pydantic_v1 import BaseModel, Field\n", + "from langchain_openai import ChatOpenAI\n", + "\n", + "\n", + "# Data model\n", + "class GradeDocuments(BaseModel):\n", + " \"\"\"Binary score for relevance check on retrieved documents.\"\"\"\n", + "\n", + " binary_score: str = Field(\n", + " description=\"Documents are relevant to the question, 'yes' or 'no'\"\n", + " )\n", + "\n", + "\n", + "# LLM with function call\n", + "llm = ChatOpenAI(model=\"gpt-4o-mini\", temperature=0)\n", + "structured_llm_grader = llm.with_structured_output(GradeDocuments)\n", + "\n", + "# Prompt\n", + "system = \"\"\"You are a grader assessing relevance of a retrieved document to a user question. \\n \n", + " It does not need to be a stringent test. The goal is to filter out erroneous retrievals. \\n\n", + " If the document contains keyword(s) or semantic meaning related to the user question, grade it as relevant. \\n\n", + " Give a binary score 'yes' or 'no' score to indicate whether the document is relevant to the question.\"\"\"\n", + "grade_prompt = ChatPromptTemplate.from_messages(\n", + " [\n", + " (\"system\", system),\n", + " (\"human\", \"Retrieved document: \\n\\n {document} \\n\\n User question: {question}\"),\n", + " ]\n", + ")\n", + "\n", + "retrieval_grader = grade_prompt | structured_llm_grader\n", + "question = \"agent memory\"\n", + "docs = retriever.get_relevant_documents(question)\n", + "doc_txt = docs[1].page_content\n", + "print(retrieval_grader.invoke({\"question\": question, \"document\": doc_txt}))" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "dcd77cc1-4587-40ec-b633-5364eab9e1ec", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The design of generative agents combines LLM with memory, planning, and reflection mechanisms to enable agents to behave conditioned on past experience and interact with other agents. Long-term memory provides the agent with the capability to retain and recall infinite information over extended periods. Short-term memory is utilized for in-context learning.\n" + ] + } + ], + "source": [ + "### Generate\n", + "\n", + "from langchain import hub\n", + "from langchain_core.output_parsers import StrOutputParser\n", + "\n", + "# Prompt\n", + "prompt = hub.pull(\"rlm/rag-prompt\")\n", + "\n", + "# LLM\n", + "llm = ChatOpenAI(model_name=\"gpt-3.5-turbo\", temperature=0)\n", + "\n", + "\n", + "# Post-processing\n", + "def format_docs(docs):\n", + " return \"\\n\\n\".join(doc.page_content for doc in docs)\n", + "\n", + "\n", + "# Chain\n", + "rag_chain = prompt | llm | StrOutputParser()\n", + "\n", + "# Run\n", + "generation = rag_chain.invoke({\"context\": docs, \"question\": question})\n", + "print(generation)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "e78931ec-940c-46ad-a0b2-f43f953f1fd7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "GradeHallucinations(binary_score='yes')" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "### Hallucination Grader\n", + "\n", + "\n", + "# Data model\n", + "class GradeHallucinations(BaseModel):\n", + " \"\"\"Binary score for hallucination present in generation answer.\"\"\"\n", + "\n", + " binary_score: str = Field(\n", + " description=\"Answer is grounded in the facts, 'yes' or 'no'\"\n", + " )\n", + "\n", + "\n", + "# LLM with function call\n", + "llm = ChatOpenAI(model=\"gpt-4o-mini\", temperature=0)\n", + "structured_llm_grader = llm.with_structured_output(GradeHallucinations)\n", + "\n", + "# Prompt\n", + "system = \"\"\"You are a grader assessing whether an LLM generation is grounded in / supported by a set of retrieved facts. \\n \n", + " Give a binary score 'yes' or 'no'. 'Yes' means that the answer is grounded in / supported by the set of facts.\"\"\"\n", + "hallucination_prompt = ChatPromptTemplate.from_messages(\n", + " [\n", + " (\"system\", system),\n", + " (\"human\", \"Set of facts: \\n\\n {documents} \\n\\n LLM generation: {generation}\"),\n", + " ]\n", + ")\n", + "\n", + "hallucination_grader = hallucination_prompt | structured_llm_grader\n", + "hallucination_grader.invoke({\"documents\": docs, \"generation\": generation})" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "bd62276f-bf26-40d0-8cff-e07b10e00321", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "GradeAnswer(binary_score='yes')" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "### Answer Grader\n", + "\n", + "\n", + "# Data model\n", + "class GradeAnswer(BaseModel):\n", + " \"\"\"Binary score to assess answer addresses question.\"\"\"\n", + "\n", + " binary_score: str = Field(\n", + " description=\"Answer addresses the question, 'yes' or 'no'\"\n", + " )\n", + "\n", + "\n", + "# LLM with function call\n", + "llm = ChatOpenAI(model=\"gpt-4o-mini\", temperature=0)\n", + "structured_llm_grader = llm.with_structured_output(GradeAnswer)\n", + "\n", + "# Prompt\n", + "system = \"\"\"You are a grader assessing whether an answer addresses / resolves a question \\n \n", + " Give a binary score 'yes' or 'no'. Yes' means that the answer resolves the question.\"\"\"\n", + "answer_prompt = ChatPromptTemplate.from_messages(\n", + " [\n", + " (\"system\", system),\n", + " (\"human\", \"User question: \\n\\n {question} \\n\\n LLM generation: {generation}\"),\n", + " ]\n", + ")\n", + "\n", + "answer_grader = answer_prompt | structured_llm_grader\n", + "answer_grader.invoke({\"question\": question, \"generation\": generation})" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "c6f4c70e-1660-4149-82c0-837f19fc9fb5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\"What is the role of memory in an agent's functioning?\"" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "### Question Re-writer\n", + "\n", + "# LLM\n", + "llm = ChatOpenAI(model=\"gpt-3.5-turbo-0125\", temperature=0)\n", + "\n", + "# Prompt\n", + "system = \"\"\"You a question re-writer that converts an input question to a better version that is optimized \\n \n", + " for vectorstore retrieval. Look at the input and try to reason about the underlying semantic intent / meaning.\"\"\"\n", + "re_write_prompt = ChatPromptTemplate.from_messages(\n", + " [\n", + " (\"system\", system),\n", + " (\n", + " \"human\",\n", + " \"Here is the initial question: \\n\\n {question} \\n Formulate an improved question.\",\n", + " ),\n", + " ]\n", + ")\n", + "\n", + "question_rewriter = re_write_prompt | llm | StrOutputParser()\n", + "question_rewriter.invoke({\"question\": question})" + ] + }, + { + "cell_type": "markdown", + "id": "276001c5-c079-4e5b-9f42-81a06704d200", + "metadata": {}, + "source": [ + "# Graph \n", + "\n", + "Capture the flow in as a graph.\n", + "\n", + "## Graph state" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "f1617e9e-66a8-4c1a-a1fe-cc936284c085", + "metadata": {}, + "outputs": [], + "source": [ + "from typing import List\n", + "\n", + "from typing_extensions import TypedDict\n", + "\n", + "\n", + "class GraphState(TypedDict):\n", + " \"\"\"\n", + " Represents the state of our graph.\n", + "\n", + " Attributes:\n", + " question: question\n", + " generation: LLM generation\n", + " documents: list of documents\n", + " \"\"\"\n", + "\n", + " question: str\n", + " generation: str\n", + " documents: List[str]" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "add509d8-6682-4127-8d95-13dd37d79702", + "metadata": {}, + "outputs": [], + "source": [ + "### Nodes\n", + "\n", + "\n", + "def retrieve(state):\n", + " \"\"\"\n", + " Retrieve documents\n", + "\n", + " Args:\n", + " state (dict): The current graph state\n", + "\n", + " Returns:\n", + " state (dict): New key added to state, documents, that contains retrieved documents\n", + " \"\"\"\n", + " print(\"---RETRIEVE---\")\n", + " question = state[\"question\"]\n", + "\n", + " # Retrieval\n", + " documents = retriever.get_relevant_documents(question)\n", + " return {\"documents\": documents, \"question\": question}\n", + "\n", + "\n", + "def generate(state):\n", + " \"\"\"\n", + " Generate answer\n", + "\n", + " Args:\n", + " state (dict): The current graph state\n", + "\n", + " Returns:\n", + " state (dict): New key added to state, generation, that contains LLM generation\n", + " \"\"\"\n", + " print(\"---GENERATE---\")\n", + " question = state[\"question\"]\n", + " documents = state[\"documents\"]\n", + "\n", + " # RAG generation\n", + " generation = rag_chain.invoke({\"context\": documents, \"question\": question})\n", + " return {\"documents\": documents, \"question\": question, \"generation\": generation}\n", + "\n", + "\n", + "def grade_documents(state):\n", + " \"\"\"\n", + " Determines whether the retrieved documents are relevant to the question.\n", + "\n", + " Args:\n", + " state (dict): The current graph state\n", + "\n", + " Returns:\n", + " state (dict): Updates documents key with only filtered relevant documents\n", + " \"\"\"\n", + "\n", + " print(\"---CHECK DOCUMENT RELEVANCE TO QUESTION---\")\n", + " question = state[\"question\"]\n", + " documents = state[\"documents\"]\n", + "\n", + " # Score each doc\n", + " filtered_docs = []\n", + " for d in documents:\n", + " score = retrieval_grader.invoke(\n", + " {\"question\": question, \"document\": d.page_content}\n", + " )\n", + " grade = score.binary_score\n", + " if grade == \"yes\":\n", + " print(\"---GRADE: DOCUMENT RELEVANT---\")\n", + " filtered_docs.append(d)\n", + " else:\n", + " print(\"---GRADE: DOCUMENT NOT RELEVANT---\")\n", + " continue\n", + " return {\"documents\": filtered_docs, \"question\": question}\n", + "\n", + "\n", + "def transform_query(state):\n", + " \"\"\"\n", + " Transform the query to produce a better question.\n", + "\n", + " Args:\n", + " state (dict): The current graph state\n", + "\n", + " Returns:\n", + " state (dict): Updates question key with a re-phrased question\n", + " \"\"\"\n", + "\n", + " print(\"---TRANSFORM QUERY---\")\n", + " question = state[\"question\"]\n", + " documents = state[\"documents\"]\n", + "\n", + " # Re-write question\n", + " better_question = question_rewriter.invoke({\"question\": question})\n", + " return {\"documents\": documents, \"question\": better_question}\n", + "\n", + "\n", + "### Edges\n", + "\n", + "\n", + "def decide_to_generate(state):\n", + " \"\"\"\n", + " Determines whether to generate an answer, or re-generate a question.\n", + "\n", + " Args:\n", + " state (dict): The current graph state\n", + "\n", + " Returns:\n", + " str: Binary decision for next node to call\n", + " \"\"\"\n", + "\n", + " print(\"---ASSESS GRADED DOCUMENTS---\")\n", + " state[\"question\"]\n", + " filtered_documents = state[\"documents\"]\n", + "\n", + " if not filtered_documents:\n", + " # All documents have been filtered check_relevance\n", + " # We will re-generate a new query\n", + " print(\n", + " \"---DECISION: ALL DOCUMENTS ARE NOT RELEVANT TO QUESTION, TRANSFORM QUERY---\"\n", + " )\n", + " return \"transform_query\"\n", + " else:\n", + " # We have relevant documents, so generate answer\n", + " print(\"---DECISION: GENERATE---\")\n", + " return \"generate\"\n", + "\n", + "\n", + "def grade_generation_v_documents_and_question(state):\n", + " \"\"\"\n", + " Determines whether the generation is grounded in the document and answers question.\n", + "\n", + " Args:\n", + " state (dict): The current graph state\n", + "\n", + " Returns:\n", + " str: Decision for next node to call\n", + " \"\"\"\n", + "\n", + " print(\"---CHECK HALLUCINATIONS---\")\n", + " question = state[\"question\"]\n", + " documents = state[\"documents\"]\n", + " generation = state[\"generation\"]\n", + "\n", + " score = hallucination_grader.invoke(\n", + " {\"documents\": documents, \"generation\": generation}\n", + " )\n", + " grade = score.binary_score\n", + "\n", + " # Check hallucination\n", + " if grade == \"yes\":\n", + " print(\"---DECISION: GENERATION IS GROUNDED IN DOCUMENTS---\")\n", + " # Check question-answering\n", + " print(\"---GRADE GENERATION vs QUESTION---\")\n", + " score = answer_grader.invoke({\"question\": question, \"generation\": generation})\n", + " grade = score.binary_score\n", + " if grade == \"yes\":\n", + " print(\"---DECISION: GENERATION ADDRESSES QUESTION---\")\n", + " return \"useful\"\n", + " else:\n", + " print(\"---DECISION: GENERATION DOES NOT ADDRESS QUESTION---\")\n", + " return \"not useful\"\n", + " else:\n", + " pprint(\"---DECISION: GENERATION IS NOT GROUNDED IN DOCUMENTS, RE-TRY---\")\n", + " return \"not supported\"" + ] + }, + { + "cell_type": "markdown", + "id": "61cd5797-1782-4d78-a277-8196d13f3e1b", + "metadata": {}, + "source": [ + "## Build Graph\n", + "\n", + "The just follows the flow we outlined in the figure above." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "0e09ca9f-e36d-4ef4-a0d5-79fdbada9fe0", + "metadata": {}, + "outputs": [], + "source": [ + "from langgraph.graph import END, StateGraph, START\n", + "\n", + "workflow = StateGraph(GraphState)\n", + "\n", + "# Define the nodes\n", + "workflow.add_node(\"retrieve\", retrieve) # retrieve\n", + "workflow.add_node(\"grade_documents\", grade_documents) # grade documents\n", + "workflow.add_node(\"generate\", generate) # generate\n", + "workflow.add_node(\"transform_query\", transform_query) # transform_query\n", + "\n", + "# Build graph\n", + "workflow.add_edge(START, \"retrieve\")\n", + "workflow.add_edge(\"retrieve\", \"grade_documents\")\n", + "workflow.add_conditional_edges(\n", + " \"grade_documents\",\n", + " decide_to_generate,\n", + " {\n", + " \"transform_query\": \"transform_query\",\n", + " \"generate\": \"generate\",\n", + " },\n", + ")\n", + "workflow.add_edge(\"transform_query\", \"retrieve\")\n", + "workflow.add_conditional_edges(\n", + " \"generate\",\n", + " grade_generation_v_documents_and_question,\n", + " {\n", + " \"not supported\": \"generate\",\n", + " \"useful\": END,\n", + " \"not useful\": \"transform_query\",\n", + " },\n", + ")\n", + "\n", + "# Compile\n", + "app = workflow.compile()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "fb69dbb9-91ee-4868-8c3c-93af3cd885be", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---RETRIEVE---\n", + "\"Node 'retrieve':\"\n", + "'\\n---\\n'\n", + "---CHECK DOCUMENT RELEVANCE TO QUESTION---\n", + "---GRADE: DOCUMENT NOT RELEVANT---\n", + "---GRADE: DOCUMENT RELEVANT---\n", + "---GRADE: DOCUMENT NOT RELEVANT---\n", + "---GRADE: DOCUMENT RELEVANT---\n", + "---ASSESS GRADED DOCUMENTS---\n", + "---DECISION: GENERATE---\n", + "\"Node 'grade_documents':\"\n", + "'\\n---\\n'\n", + "---GENERATE---\n", + "---CHECK HALLUCINATIONS---\n", + "---DECISION: GENERATION IS GROUNDED IN DOCUMENTS---\n", + "---GRADE GENERATION vs QUESTION---\n", + "---DECISION: GENERATION ADDRESSES QUESTION---\n", + "\"Node 'generate':\"\n", + "'\\n---\\n'\n", + "('Short-term memory is used for in-context learning in agents, allowing them '\n", + " 'to learn quickly. Long-term memory enables agents to retain and recall vast '\n", + " 'amounts of information over extended periods. Agents can also utilize '\n", + " 'external tools like APIs to access additional information beyond what is '\n", + " 'stored in their memory.')\n" + ] + } + ], + "source": [ + "from pprint import pprint\n", + "\n", + "# Run\n", + "inputs = {\"question\": \"Explain how the different types of agent memory work?\"}\n", + "for output in app.stream(inputs):\n", + " for key, value in output.items():\n", + " # Node\n", + " pprint(f\"Node '{key}':\")\n", + " # Optional: print full state at each node\n", + " # pprint.pprint(value[\"keys\"], indent=2, width=80, depth=None)\n", + " pprint(\"\\n---\\n\")\n", + "\n", + "# Final generation\n", + "pprint(value[\"generation\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "4138bc51-8c84-4b8a-8d24-f7f470721f6f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---RETRIEVE---\n", + "\"Node 'retrieve':\"\n", + "'\\n---\\n'\n", + "---CHECK DOCUMENT RELEVANCE TO QUESTION---\n", + "---GRADE: DOCUMENT RELEVANT---\n", + "---GRADE: DOCUMENT NOT RELEVANT---\n", + "---GRADE: DOCUMENT RELEVANT---\n", + "---GRADE: DOCUMENT RELEVANT---\n", + "---ASSESS GRADED DOCUMENTS---\n", + "---DECISION: GENERATE---\n", + "\"Node 'grade_documents':\"\n", + "'\\n---\\n'\n", + "---GENERATE---\n", + "---CHECK HALLUCINATIONS---\n", + "---DECISION: GENERATION IS GROUNDED IN DOCUMENTS---\n", + "---GRADE GENERATION vs QUESTION---\n", + "---DECISION: GENERATION ADDRESSES QUESTION---\n", + "\"Node 'generate':\"\n", + "'\\n---\\n'\n", + "('Chain of thought prompting works by repeatedly prompting the model to ask '\n", + " 'follow-up questions to construct the thought process iteratively. This '\n", + " 'method can be combined with queries to search for relevant entities and '\n", + " 'content to add back into the context. It extends the thought process by '\n", + " 'exploring multiple reasoning possibilities at each step, creating a tree '\n", + " 'structure of thoughts.')\n" + ] + } + ], + "source": [ + "inputs = {\"question\": \"Explain how chain of thought prompting works?\"}\n", + "for output in app.stream(inputs):\n", + " for key, value in output.items():\n", + " # Node\n", + " pprint(f\"Node '{key}':\")\n", + " # Optional: print full state at each node\n", + " # pprint.pprint(value[\"keys\"], indent=2, width=80, depth=None)\n", + " pprint(\"\\n---\\n\")\n", + "\n", + "# Final generation\n", + "pprint(value[\"generation\"])" + ] + }, + { + "cell_type": "markdown", + "id": "548f1c5b-4108-4aae-8abb-ec171b511b92", + "metadata": {}, + "source": [ + "LangSmith Traces - \n", + " \n", + "* https://smith.langchain.com/public/55d6180f-aab8-42bc-8799-dadce6247d9b/r\n", + "\n", + "* https://smith.langchain.com/public/1c6bf654-61b2-4fc5-9889-054b020c78aa/r" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/rag/langgraph_self_rag_local.ipynb b/examples/rag/langgraph_self_rag_local.ipynb new file mode 100644 index 000000000..22e84d79a --- /dev/null +++ b/examples/rag/langgraph_self_rag_local.ipynb @@ -0,0 +1,747 @@ +{ + "cells": [ + { + "attachments": { + "5fca0a3e-d13d-4bfa-95ea-58203640cc7a.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "848ba742-7443-4123-8115-061da9823309", + "metadata": {}, + "source": [ + "# Self-RAG using local LLMs\n", + "\n", + "Self-RAG is a strategy for RAG that incorporates self-reflection / self-grading on retrieved documents and generations. \n", + "\n", + "In the [paper](https://arxiv.org/abs/2310.11511), a few decisions are made:\n", + "\n", + "1. Should I retrieve from retriever, `R` -\n", + "\n", + "* Input: `x (question)` OR `x (question)`, `y (generation)`\n", + "* Decides when to retrieve `D` chunks with `R`\n", + "* Output: `yes, no, continue`\n", + "\n", + "2. Are the retrieved passages `D` relevant to the question `x` -\n", + "\n", + "* * Input: (`x (question)`, `d (chunk)`) for `d` in `D`\n", + "* `d` provides useful information to solve `x`\n", + "* Output: `relevant, irrelevant`\n", + "\n", + "3. Are the LLM generation from each chunk in `D` is relevant to the chunk (hallucinations, etc) -\n", + "\n", + "* Input: `x (question)`, `d (chunk)`, `y (generation)` for `d` in `D`\n", + "* All of the verification-worthy statements in `y (generation)` are supported by `d`\n", + "* Output: `{fully supported, partially supported, no support`\n", + "\n", + "4. The LLM generation from each chunk in `D` is a useful response to `x (question)` -\n", + "\n", + "* Input: `x (question)`, `y (generation)` for `d` in `D`\n", + "* `y (generation)` is a useful response to `x (question)`.\n", + "* Output: `{5, 4, 3, 2, 1}`\n", + "\n", + "We will implement some of these ideas from scratch using [LangGraph](https://langchain-ai.github.io/langgraph/).\n", + "\n", + "![Screenshot 2024-04-01 at 12.42.59 PM.png](attachment:5fca0a3e-d13d-4bfa-95ea-58203640cc7a.png)" + ] + }, + { + "cell_type": "markdown", + "id": "9ed0a85a-a33b-40a6-99fa-2444bf57a6cc", + "metadata": {}, + "source": [ + "## Setup\n", + "\n", + "First let's install our required packages and set our API keys" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d7f9cc6d-a70c-433a-b0ad-ea47c5a0717e", + "metadata": {}, + "outputs": [], + "source": [ + "%capture --no-stderr\n", + "%pip install -U langchain-nomic langchain_community tiktoken langchainhub chromadb langchain langgraph nomic[local]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "71c540ca", + "metadata": {}, + "outputs": [], + "source": [ + "import getpass\n", + "import os\n", + "\n", + "\n", + "def _set_env(key: str):\n", + " if key not in os.environ:\n", + " os.environ[key] = getpass.getpass(f\"{key}:\")\n", + "\n", + "\n", + "_set_env(\"NOMIC_API_KEY\")" + ] + }, + { + "cell_type": "markdown", + "id": "05e8cf60", + "metadata": {}, + "source": [ + "
\n", + "

Set up LangSmith for LangGraph development

\n", + "

\n", + " Sign up for LangSmith to quickly spot issues and improve the performance of your LangGraph projects. LangSmith lets you use trace data to debug, test, and monitor your LLM apps built with LangGraph — read more about how to get started here. \n", + "

\n", + "
" + ] + }, + { + "cell_type": "markdown", + "id": "ccc6b6bd-a2fa-4a43-83b7-704b8b6fb855", + "metadata": {}, + "source": [ + "### LLMs\n", + "\n", + "#### Local Embeddings\n", + "\n", + "You can use `GPT4AllEmbeddings()` from Nomic, which can access use Nomic's recently released [v1](https://blog.nomic.ai/posts/nomic-embed-text-v1) and [v1.5](https://blog.nomic.ai/posts/nomic-embed-matryoshka) embeddings.\n", + "\n", + "\n", + "Follow the documentation [here](https://docs.gpt4all.io/gpt4all_python_embedding.html#supported-embedding-models).\n", + "\n", + "#### Local LLM\n", + "\n", + "(1) Download [Ollama app](https://ollama.ai/).\n", + "\n", + "(2) Download a `Mistral` model from various Mistral versions [here](https://ollama.ai/library/mistral) and Mixtral versions [here](https://ollama.ai/library/mixtral) available.\n", + "```\n", + "ollama pull mistral\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "bedffc73-6b10-42c8-8768-2085c8ed3398", + "metadata": {}, + "outputs": [], + "source": [ + "# Ollama model name\n", + "local_llm = \"mistral\"" + ] + }, + { + "cell_type": "markdown", + "id": "ba68a46d-b617-4fdc-9113-fabdcf736feb", + "metadata": {}, + "source": [ + "## Create Index\n", + "\n", + "Let's index 3 blog posts." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c3bb9060-ad74-4470-9991-2ba167b6b8d8", + "metadata": {}, + "outputs": [], + "source": [ + "from langchain.text_splitter import RecursiveCharacterTextSplitter\n", + "from langchain_community.document_loaders import WebBaseLoader\n", + "from langchain_community.vectorstores import Chroma\n", + "from langchain_nomic.embeddings import NomicEmbeddings\n", + "\n", + "urls = [\n", + " \"https://lilianweng.github.io/posts/2023-06-23-agent/\",\n", + " \"https://lilianweng.github.io/posts/2023-03-15-prompt-engineering/\",\n", + " \"https://lilianweng.github.io/posts/2023-10-25-adv-attack-llm/\",\n", + "]\n", + "\n", + "docs = [WebBaseLoader(url).load() for url in urls]\n", + "docs_list = [item for sublist in docs for item in sublist]\n", + "\n", + "text_splitter = RecursiveCharacterTextSplitter.from_tiktoken_encoder(\n", + " chunk_size=250, chunk_overlap=0\n", + ")\n", + "doc_splits = text_splitter.split_documents(docs_list)\n", + "\n", + "# Add to vectorDB\n", + "vectorstore = Chroma.from_documents(\n", + " documents=doc_splits,\n", + " collection_name=\"rag-chroma\",\n", + " embedding=NomicEmbeddings(model=\"nomic-embed-text-v1.5\", inference_mode=\"local\"),\n", + ")\n", + "retriever = vectorstore.as_retriever()" + ] + }, + { + "cell_type": "markdown", + "id": "cc60ff95-7e12-4004-b18e-a067a2dcc201", + "metadata": {}, + "source": [ + "## LLMs" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "3aad0c60-3208-48fb-af82-0024630b4da1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'score': 'yes'}\n" + ] + } + ], + "source": [ + "### Retrieval Grader\n", + "\n", + "from langchain.prompts import PromptTemplate\n", + "from langchain_community.chat_models import ChatOllama\n", + "from langchain_core.output_parsers import JsonOutputParser\n", + "\n", + "# LLM\n", + "llm = ChatOllama(model=local_llm, format=\"json\", temperature=0)\n", + "\n", + "prompt = PromptTemplate(\n", + " template=\"\"\"You are a grader assessing relevance of a retrieved document to a user question. \\n \n", + " Here is the retrieved document: \\n\\n {document} \\n\\n\n", + " Here is the user question: {question} \\n\n", + " If the document contains keywords related to the user question, grade it as relevant. \\n\n", + " It does not need to be a stringent test. The goal is to filter out erroneous retrievals. \\n\n", + " Give a binary score 'yes' or 'no' score to indicate whether the document is relevant to the question. \\n\n", + " Provide the binary score as a JSON with a single key 'score' and no premable or explanation.\"\"\",\n", + " input_variables=[\"question\", \"document\"],\n", + ")\n", + "\n", + "retrieval_grader = prompt | llm | JsonOutputParser()\n", + "question = \"agent memory\"\n", + "docs = retriever.get_relevant_documents(question)\n", + "doc_txt = docs[1].page_content\n", + "print(retrieval_grader.invoke({\"question\": question, \"document\": doc_txt}))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "e5e45953-248d-492f-af28-d5e80c664c95", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " In an LLM-powered autonomous agent system, the Large Language Model (LLM) functions as the agent's brain. The agent has key components including memory, planning, and reflection mechanisms. The memory component is a long-term memory module that records a comprehensive list of agents’ experience in natural language. It includes a memory stream, which is an external database for storing past experiences. The reflection mechanism synthesizes memories into higher-level inferences over time and guides the agent's future behavior.\n" + ] + } + ], + "source": [ + "### Generate\n", + "\n", + "from langchain import hub\n", + "from langchain_core.output_parsers import StrOutputParser\n", + "\n", + "# Prompt\n", + "prompt = hub.pull(\"rlm/rag-prompt\")\n", + "\n", + "# LLM\n", + "llm = ChatOllama(model=local_llm, temperature=0)\n", + "\n", + "\n", + "# Post-processing\n", + "def format_docs(docs):\n", + " return \"\\n\\n\".join(doc.page_content for doc in docs)\n", + "\n", + "\n", + "# Chain\n", + "rag_chain = prompt | llm | StrOutputParser()\n", + "\n", + "# Run\n", + "generation = rag_chain.invoke({\"context\": docs, \"question\": question})\n", + "print(generation)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "56297862-df87-42a7-ba9d-310926dfb328", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'score': 'yes'}" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "### Hallucination Grader\n", + "\n", + "# LLM\n", + "llm = ChatOllama(model=local_llm, format=\"json\", temperature=0)\n", + "\n", + "# Prompt\n", + "prompt = PromptTemplate(\n", + " template=\"\"\"You are a grader assessing whether an answer is grounded in / supported by a set of facts. \\n \n", + " Here are the facts:\n", + " \\n ------- \\n\n", + " {documents} \n", + " \\n ------- \\n\n", + " Here is the answer: {generation}\n", + " Give a binary score 'yes' or 'no' score to indicate whether the answer is grounded in / supported by a set of facts. \\n\n", + " Provide the binary score as a JSON with a single key 'score' and no preamble or explanation.\"\"\",\n", + " input_variables=[\"generation\", \"documents\"],\n", + ")\n", + "\n", + "hallucination_grader = prompt | llm | JsonOutputParser()\n", + "hallucination_grader.invoke({\"documents\": docs, \"generation\": generation})" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "e1dd9174-2df6-45b1-8e69-13381f579c39", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'score': 'yes'}" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "### Answer Grader\n", + "\n", + "# LLM\n", + "llm = ChatOllama(model=local_llm, format=\"json\", temperature=0)\n", + "\n", + "# Prompt\n", + "prompt = PromptTemplate(\n", + " template=\"\"\"You are a grader assessing whether an answer is useful to resolve a question. \\n \n", + " Here is the answer:\n", + " \\n ------- \\n\n", + " {generation} \n", + " \\n ------- \\n\n", + " Here is the question: {question}\n", + " Give a binary score 'yes' or 'no' to indicate whether the answer is useful to resolve a question. \\n\n", + " Provide the binary score as a JSON with a single key 'score' and no preamble or explanation.\"\"\",\n", + " input_variables=[\"generation\", \"question\"],\n", + ")\n", + "\n", + "answer_grader = prompt | llm | JsonOutputParser()\n", + "answer_grader.invoke({\"question\": question, \"generation\": generation})" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "5216d92b-1ca1-4bcf-a34f-c99ec2766b54", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "' What is agent memory and how can it be effectively utilized in vector database retrieval?'" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "### Question Re-writer\n", + "\n", + "# LLM\n", + "llm = ChatOllama(model=local_llm, temperature=0)\n", + "\n", + "# Prompt\n", + "re_write_prompt = PromptTemplate(\n", + " template=\"\"\"You a question re-writer that converts an input question to a better version that is optimized \\n \n", + " for vectorstore retrieval. Look at the initial and formulate an improved question. \\n\n", + " Here is the initial question: \\n\\n {question}. Improved question with no preamble: \\n \"\"\",\n", + " input_variables=[\"generation\", \"question\"],\n", + ")\n", + "\n", + "question_rewriter = re_write_prompt | llm | StrOutputParser()\n", + "question_rewriter.invoke({\"question\": question})" + ] + }, + { + "cell_type": "markdown", + "id": "3d3339b9-5f30-4d54-bfc9-9091c6035955", + "metadata": {}, + "source": [ + "# Graph \n", + "\n", + "Capture the flow in as a graph.\n", + "\n", + "## Graph state" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "90fb1dc6-c482-483a-8441-39965c401beb", + "metadata": {}, + "outputs": [], + "source": [ + "from typing import List\n", + "\n", + "from typing_extensions import TypedDict\n", + "\n", + "\n", + "class GraphState(TypedDict):\n", + " \"\"\"\n", + " Represents the state of our graph.\n", + "\n", + " Attributes:\n", + " question: question\n", + " generation: LLM generation\n", + " documents: list of documents\n", + " \"\"\"\n", + "\n", + " question: str\n", + " generation: str\n", + " documents: List[str]" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "5324ea49-5745-47b5-a0a5-bf58c8babe46", + "metadata": {}, + "outputs": [], + "source": [ + "### Nodes\n", + "\n", + "\n", + "def retrieve(state):\n", + " \"\"\"\n", + " Retrieve documents\n", + "\n", + " Args:\n", + " state (dict): The current graph state\n", + "\n", + " Returns:\n", + " state (dict): New key added to state, documents, that contains retrieved documents\n", + " \"\"\"\n", + " print(\"---RETRIEVE---\")\n", + " question = state[\"question\"]\n", + "\n", + " # Retrieval\n", + " documents = retriever.get_relevant_documents(question)\n", + " return {\"documents\": documents, \"question\": question}\n", + "\n", + "\n", + "def generate(state):\n", + " \"\"\"\n", + " Generate answer\n", + "\n", + " Args:\n", + " state (dict): The current graph state\n", + "\n", + " Returns:\n", + " state (dict): New key added to state, generation, that contains LLM generation\n", + " \"\"\"\n", + " print(\"---GENERATE---\")\n", + " question = state[\"question\"]\n", + " documents = state[\"documents\"]\n", + "\n", + " # RAG generation\n", + " generation = rag_chain.invoke({\"context\": documents, \"question\": question})\n", + " return {\"documents\": documents, \"question\": question, \"generation\": generation}\n", + "\n", + "\n", + "def grade_documents(state):\n", + " \"\"\"\n", + " Determines whether the retrieved documents are relevant to the question.\n", + "\n", + " Args:\n", + " state (dict): The current graph state\n", + "\n", + " Returns:\n", + " state (dict): Updates documents key with only filtered relevant documents\n", + " \"\"\"\n", + "\n", + " print(\"---CHECK DOCUMENT RELEVANCE TO QUESTION---\")\n", + " question = state[\"question\"]\n", + " documents = state[\"documents\"]\n", + "\n", + " # Score each doc\n", + " filtered_docs = []\n", + " for d in documents:\n", + " score = retrieval_grader.invoke(\n", + " {\"question\": question, \"document\": d.page_content}\n", + " )\n", + " grade = score[\"score\"]\n", + " if grade == \"yes\":\n", + " print(\"---GRADE: DOCUMENT RELEVANT---\")\n", + " filtered_docs.append(d)\n", + " else:\n", + " print(\"---GRADE: DOCUMENT NOT RELEVANT---\")\n", + " continue\n", + " return {\"documents\": filtered_docs, \"question\": question}\n", + "\n", + "\n", + "def transform_query(state):\n", + " \"\"\"\n", + " Transform the query to produce a better question.\n", + "\n", + " Args:\n", + " state (dict): The current graph state\n", + "\n", + " Returns:\n", + " state (dict): Updates question key with a re-phrased question\n", + " \"\"\"\n", + "\n", + " print(\"---TRANSFORM QUERY---\")\n", + " question = state[\"question\"]\n", + " documents = state[\"documents\"]\n", + "\n", + " # Re-write question\n", + " better_question = question_rewriter.invoke({\"question\": question})\n", + " return {\"documents\": documents, \"question\": better_question}\n", + "\n", + "\n", + "### Edges\n", + "\n", + "\n", + "def decide_to_generate(state):\n", + " \"\"\"\n", + " Determines whether to generate an answer, or re-generate a question.\n", + "\n", + " Args:\n", + " state (dict): The current graph state\n", + "\n", + " Returns:\n", + " str: Binary decision for next node to call\n", + " \"\"\"\n", + "\n", + " print(\"---ASSESS GRADED DOCUMENTS---\")\n", + " state[\"question\"]\n", + " filtered_documents = state[\"documents\"]\n", + "\n", + " if not filtered_documents:\n", + " # All documents have been filtered check_relevance\n", + " # We will re-generate a new query\n", + " print(\n", + " \"---DECISION: ALL DOCUMENTS ARE NOT RELEVANT TO QUESTION, TRANSFORM QUERY---\"\n", + " )\n", + " return \"transform_query\"\n", + " else:\n", + " # We have relevant documents, so generate answer\n", + " print(\"---DECISION: GENERATE---\")\n", + " return \"generate\"\n", + "\n", + "\n", + "def grade_generation_v_documents_and_question(state):\n", + " \"\"\"\n", + " Determines whether the generation is grounded in the document and answers question.\n", + "\n", + " Args:\n", + " state (dict): The current graph state\n", + "\n", + " Returns:\n", + " str: Decision for next node to call\n", + " \"\"\"\n", + "\n", + " print(\"---CHECK HALLUCINATIONS---\")\n", + " question = state[\"question\"]\n", + " documents = state[\"documents\"]\n", + " generation = state[\"generation\"]\n", + "\n", + " score = hallucination_grader.invoke(\n", + " {\"documents\": documents, \"generation\": generation}\n", + " )\n", + " grade = score[\"score\"]\n", + "\n", + " # Check hallucination\n", + " if grade == \"yes\":\n", + " print(\"---DECISION: GENERATION IS GROUNDED IN DOCUMENTS---\")\n", + " # Check question-answering\n", + " print(\"---GRADE GENERATION vs QUESTION---\")\n", + " score = answer_grader.invoke({\"question\": question, \"generation\": generation})\n", + " grade = score[\"score\"]\n", + " if grade == \"yes\":\n", + " print(\"---DECISION: GENERATION ADDRESSES QUESTION---\")\n", + " return \"useful\"\n", + " else:\n", + " print(\"---DECISION: GENERATION DOES NOT ADDRESS QUESTION---\")\n", + " return \"not useful\"\n", + " else:\n", + " print(\"---DECISION: GENERATION IS NOT GROUNDED IN DOCUMENTS, RE-TRY---\")\n", + " return \"not supported\"" + ] + }, + { + "cell_type": "markdown", + "id": "bdf3826c-b668-4f0b-bf83-81c40baaaf02", + "metadata": {}, + "source": [ + "## Build Graph\n", + "\n", + "This just follows the flow we outlined in the figure above." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "5605dee4-b2df-46ae-a640-cc2ed90c21a6", + "metadata": {}, + "outputs": [], + "source": [ + "from langgraph.graph import END, StateGraph, START\n", + "\n", + "workflow = StateGraph(GraphState)\n", + "\n", + "# Define the nodes\n", + "workflow.add_node(\"retrieve\", retrieve) # retrieve\n", + "workflow.add_node(\"grade_documents\", grade_documents) # grade documents\n", + "workflow.add_node(\"generate\", generate) # generate\n", + "workflow.add_node(\"transform_query\", transform_query) # transform_query\n", + "\n", + "# Build graph\n", + "workflow.add_edge(START, \"retrieve\")\n", + "workflow.add_edge(\"retrieve\", \"grade_documents\")\n", + "workflow.add_conditional_edges(\n", + " \"grade_documents\",\n", + " decide_to_generate,\n", + " {\n", + " \"transform_query\": \"transform_query\",\n", + " \"generate\": \"generate\",\n", + " },\n", + ")\n", + "workflow.add_edge(\"transform_query\", \"retrieve\")\n", + "workflow.add_conditional_edges(\n", + " \"generate\",\n", + " grade_generation_v_documents_and_question,\n", + " {\n", + " \"not supported\": \"generate\",\n", + " \"useful\": END,\n", + " \"not useful\": \"transform_query\",\n", + " },\n", + ")\n", + "\n", + "# Compile\n", + "app = workflow.compile()" + ] + }, + { + "cell_type": "markdown", + "id": "105ae1b5-6963-4186-bb83-6d6cb96d095f", + "metadata": {}, + "source": [ + "## Run\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "26a64f7d-0c14-4e31-a67f-63021dee626e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---RETRIEVE---\n", + "\"Node 'retrieve':\"\n", + "'\\n---\\n'\n", + "---CHECK DOCUMENT RELEVANCE TO QUESTION---\n", + "---GRADE: DOCUMENT RELEVANT---\n", + "---GRADE: DOCUMENT RELEVANT---\n", + "---GRADE: DOCUMENT RELEVANT---\n", + "---GRADE: DOCUMENT RELEVANT---\n", + "\"Node 'grade_documents':\"\n", + "'\\n---\\n'\n", + "---ASSESS GRADED DOCUMENTS---\n", + "---DECISION: GENERATE---\n", + "---GENERATE---\n", + "\"Node 'generate':\"\n", + "'\\n---\\n'\n", + "---CHECK HALLUCINATIONS---\n", + "---DECISION: GENERATION IS GROUNDED IN DOCUMENTS---\n", + "---GRADE GENERATION vs QUESTION---\n", + "---DECISION: GENERATION ADDRESSES QUESTION---\n", + "\"Node '__end__':\"\n", + "'\\n---\\n'\n", + "(' In a LLM-powered autonomous agent system, memory is a key component that '\n", + " 'enables agents to store and retrieve information. There are different types '\n", + " 'of memory in human brains, such as sensory memory which retains impressions '\n", + " 'of sensory information for a few seconds, and long-term memory which records '\n", + " \"experiences for extended periods (Lil'Log, 2023). In the context of LLM \"\n", + " 'agents, memory is often implemented as an external database or memory stream '\n", + " \"(Lil'Log, 2023). The agent can consult this memory to inform its behavior \"\n", + " 'based on relevance, recency, and importance. Additionally, reflection '\n", + " 'mechanisms synthesize memories into higher-level inferences over time and '\n", + " \"guide the agent's future behavior (Lil'Log, 2023).\")\n" + ] + } + ], + "source": [ + "from pprint import pprint\n", + "\n", + "# Run\n", + "inputs = {\"question\": \"Explain how the different types of agent memory work?\"}\n", + "for output in app.stream(inputs):\n", + " for key, value in output.items():\n", + " # Node\n", + " pprint(f\"Node '{key}':\")\n", + " # Optional: print full state at each node\n", + " # pprint.pprint(value[\"keys\"], indent=2, width=80, depth=None)\n", + " pprint(\"\\n---\\n\")\n", + "\n", + "# Final generation\n", + "pprint(value[\"generation\"])" + ] + }, + { + "cell_type": "markdown", + "id": "f9a27907-2611-4791-910b-0d66c59f5cf5", + "metadata": {}, + "source": [ + "Trace: \n", + "\n", + "https://smith.langchain.com/public/4163a342-5260-4852-8602-bda3f95177e7/r" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/rag/langgraph_self_rag_pinecone_movies.ipynb b/examples/rag/langgraph_self_rag_pinecone_movies.ipynb new file mode 100644 index 000000000..bdcc129c4 --- /dev/null +++ b/examples/rag/langgraph_self_rag_pinecone_movies.ipynb @@ -0,0 +1,474 @@ +{ + "cells": [ + { + "attachments": { + "15cba0ab-a549-4909-8373-fb761e384eff.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "919fe33c-0149-4f7d-b200-544a18986c9a", + "metadata": {}, + "source": [ + "# Self RAG\n", + "\n", + "Self-RAG is a strategy for RAG that incorporates self-reflection / self-grading on retrieved documents and generations. \n", + "\n", + "[Paper](https://arxiv.org/abs/2310.11511)\n", + "\n", + "![Screenshot 2024-04-01 at 12.41.50 PM.png](attachment:15cba0ab-a549-4909-8373-fb761e384eff.png)" + ] + }, + { + "cell_type": "markdown", + "id": "72f3ee57-68ab-4040-bd36-4014e2a23d96", + "metadata": {}, + "source": [ + "# Environment " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a384cc48-0425-4e8f-aafc-cfb8e56025c9", + "metadata": {}, + "outputs": [], + "source": [ + "%pip install -qU langchain-pinecone langchain-openai langchainhub langgraph" + ] + }, + { + "cell_type": "markdown", + "id": "532d91fb-381e-4e11-b3b1-254321351773", + "metadata": {}, + "source": [ + "### Tracing\n", + "\n", + "Use [LangSmith](https://docs.smith.langchain.com/) for tracing (shown at bottom)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ccc3dae5-1df6-48ca-af8a-50f0e6128876", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n\nos.environ[\"LANGCHAIN_TRACING_V2\"] = \"true\"\nos.environ[\"LANGCHAIN_ENDPOINT\"] = \"https://api.smith.langchain.com\"\nos.environ[\"LANGCHAIN_API_KEY\"] = \"\"" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "88637820", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n\nos.environ[\"LANGCHAIN_PROJECT\"] = \"pinecone-devconnect\"" + ] + }, + { + "cell_type": "markdown", + "id": "c27bebdc-be71-4130-ab9d-42f09f87658b", + "metadata": {}, + "source": [ + "## Retriever\n", + " \n", + "Let's use Pinecone's sample movies database" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "565a6d44-2c9f-4fff-b1ec-eea05df9350d", + "metadata": {}, + "outputs": [], + "source": [ + "from langchain_openai import OpenAIEmbeddings\nfrom langchain_pinecone import PineconeVectorStore\n\n# use pinecone movies database\n\n# Add to vectorDB\nvectorstore = PineconeVectorStore(\n embedding=OpenAIEmbeddings(),\n index_name=\"sample-movies\",\n text_key=\"summary\",\n)\nretriever = vectorstore.as_retriever()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "1aeb4373", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "# Avatar\n", + "On the alien world of Pandora, paraplegic Marine Jake Sully uses an avatar to walk again and becomes torn between his mission and protecting the planet's indigenous Na'vi people. The film stars Sam Worthington, Zoe Saldana, and Sigourney Weaver.\n", + "\n", + "# Top Gun: Maverick\n", + "Capt. Pete \"Maverick\" Mitchell, after decades of service as one of the Navy's top aviators, confronts his past while training a new squad for a dangerous mission. Tom Cruise reprises his iconic role, showcasing thrilling aerial stunts.\n", + "\n", + "# Jurassic World Dominion\n", + "The film concludes the story of Jurassic World, with humanity now living alongside dinosaurs. It follows Owen Grady and Claire Dearing as they navigate this new world.\n", + "\n", + "# Aquaman\n", + "Arthur Curry learns he is the heir to the underwater kingdom of Atlantis and must step forward to lead his people and be a hero to the world. Stars Jason Momoa, Amber Heard, and Willem Dafoe.\n", + "\n" + ] + } + ], + "source": [ + "docs = retriever.invoke(\"James Cameron\")\nfor doc in docs:\n print(\"# \" + doc.metadata[\"title\"])\n print(doc.page_content)\n print()" + ] + }, + { + "cell_type": "markdown", + "id": "29c12f74-53e2-43cc-896f-875d1c5d9d93", + "metadata": {}, + "source": [ + "## Structured Output - Retrieval Grader" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "1fafad21-60cc-483e-92a3-6a7edb1838e3", + "metadata": {}, + "outputs": [], + "source": [ + "### Retrieval Grader\n", + "\n", + "from langchain import hub\n", + "from langchain_core.pydantic_v1 import BaseModel, Field\n", + "from langchain_openai import ChatOpenAI\n", + "\n", + "\n", + "# Data model\n", + "class GradeDocuments(BaseModel):\n", + " \"\"\"Binary score for relevance check on retrieved documents.\"\"\"\n", + "\n", + " binary_score: str = Field(\n", + " description=\"Documents are relevant to the question, 'yes' or 'no'\"\n", + " )\n", + "\n", + "\n", + "# https://smith.langchain.com/hub/efriis/self-rag-retrieval-grader\n", + "grade_prompt = hub.pull(\"efriis/self-rag-retrieval-grader\")\n", + "\n", + "# LLM with function call\n", + "llm = ChatOpenAI(model=\"gpt-4o-mini\", temperature=0)\n", + "structured_llm_grader = llm.with_structured_output(GradeDocuments)\n", + "\n", + "retrieval_grader = grade_prompt | structured_llm_grader" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "2e79eed8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Arthur Curry learns he is the heir to the underwater kingdom of Atlantis and must step forward to lead his people and be a hero to the world. Stars Jason Momoa, Amber Heard, and Willem Dafoe.\n", + "binary_score='yes'\n" + ] + } + ], + "source": [ + "# Test the retrieval grader\nquestion = \"movies starring jason momoa\"\ndocs = retriever.invoke(question)\ndoc_txt = docs[0].page_content\nprint(doc_txt)\nprint(retrieval_grader.invoke({\"question\": question, \"document\": doc_txt}))" + ] + }, + { + "cell_type": "markdown", + "id": "c06abc65", + "metadata": {}, + "source": [ + "# Generation Step\n", + "\n", + "Standard RAG" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "dcd77cc1-4587-40ec-b633-5364eab9e1ec", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Jason Momoa stars in the movies \"Aquaman\" and \"Furious 7.\"\n" + ] + } + ], + "source": [ + "### Generate\n\nfrom langchain import hub\nfrom langchain_core.output_parsers import StrOutputParser\n\n# Prompt\nprompt = hub.pull(\"rlm/rag-prompt\")\n\n# LLM\nllm = ChatOpenAI(model_name=\"gpt-3.5-turbo\", temperature=0)\n\n# Chain\nrag_chain = prompt | llm | StrOutputParser()\n\n# Run\ngeneration = rag_chain.invoke({\"context\": docs, \"question\": question})\nprint(generation)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "e78931ec-940c-46ad-a0b2-f43f953f1fd7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Jason Momoa stars in the movies \"Aquaman\" and \"Furious 7.\"\n" + ] + }, + { + "data": { + "text/plain": [ + "GradeHallucinations(binary_score='yes')" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "### Hallucination Grader\n", + "\n", + "\n", + "# Data model\n", + "class GradeHallucinations(BaseModel):\n", + " \"\"\"Binary score for hallucination present in generation answer.\"\"\"\n", + "\n", + " binary_score: str = Field(\n", + " description=\"Answer is grounded in the facts, 'yes' or 'no'\"\n", + " )\n", + "\n", + "\n", + "# LLM with function call\n", + "llm = ChatOpenAI(model=\"gpt-4o-mini\", temperature=0)\n", + "structured_llm_grader = llm.with_structured_output(GradeHallucinations)\n", + "\n", + "# https://smith.langchain.com/hub/efriis/self-rag-hallucination-grader\n", + "hallucination_prompt = hub.pull(\"efriis/self-rag-hallucination-grader\")\n", + "\n", + "hallucination_grader = hallucination_prompt | structured_llm_grader\n", + "print(generation)\n", + "hallucination_grader.invoke({\"documents\": docs, \"generation\": generation})" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "bd62276f-bf26-40d0-8cff-e07b10e00321", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "movies starring jason momoa\n", + "Jason Momoa stars in the movies \"Aquaman\" and \"Furious 7.\"\n" + ] + }, + { + "data": { + "text/plain": [ + "GradeAnswer(binary_score='yes')" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "### Answer Grader\n", + "\n", + "\n", + "# Data model\n", + "class GradeAnswer(BaseModel):\n", + " \"\"\"Binary score to assess answer addresses question.\"\"\"\n", + "\n", + " binary_score: str = Field(\n", + " description=\"Answer addresses the question, 'yes' or 'no'\"\n", + " )\n", + "\n", + "\n", + "# LLM with function call\n", + "llm = ChatOpenAI(model=\"gpt-4o-mini\", temperature=0)\n", + "structured_llm_grader = llm.with_structured_output(GradeAnswer)\n", + "\n", + "# Prompt\n", + "answer_prompt = hub.pull(\"efriis/self-rag-answer-grader\")\n", + "\n", + "answer_grader = answer_prompt | structured_llm_grader\n", + "print(question)\n", + "print(generation)\n", + "answer_grader.invoke({\"question\": question, \"generation\": generation})" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "c6f4c70e-1660-4149-82c0-837f19fc9fb5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "movies starring jason momoa\n" + ] + }, + { + "data": { + "text/plain": [ + "'Which movies feature Jason Momoa in a leading role?'" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "### Question Re-writer\n\n# LLM\nllm = ChatOpenAI(model=\"gpt-3.5-turbo-0125\", temperature=0)\n\n# Prompt\nre_write_prompt = hub.pull(\"efriis/self-rag-question-rewriter\")\n\nquestion_rewriter = re_write_prompt | llm | StrOutputParser()\nprint(question)\nquestion_rewriter.invoke({\"question\": question})" + ] + }, + { + "cell_type": "markdown", + "id": "276001c5-c079-4e5b-9f42-81a06704d200", + "metadata": {}, + "source": [ + "# Graph \n", + "\n", + "Capture the flow in as a graph.\n", + "\n", + "## Graph state" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "f1617e9e-66a8-4c1a-a1fe-cc936284c085", + "metadata": {}, + "outputs": [], + "source": [ + "from typing import List\n\nfrom typing_extensions import TypedDict\n\n\nclass GraphState(TypedDict):\n \"\"\"\n Represents the state of our graph.\n\n Attributes:\n question: question\n generation: LLM generation\n documents: list of documents\n \"\"\"\n\n question: str\n generation: str\n documents: List[str]" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "add509d8-6682-4127-8d95-13dd37d79702", + "metadata": {}, + "outputs": [], + "source": [ + "### Nodes\n\n\ndef retrieve(state):\n \"\"\"\n Retrieve documents\n\n Args:\n state (dict): The current graph state\n\n Returns:\n state (dict): New key added to state, documents, that contains retrieved documents\n \"\"\"\n print(\"---RETRIEVE---\")\n question = state[\"question\"]\n\n # Retrieval\n documents = retriever.invoke(question)\n return {\"documents\": documents, \"question\": question}\n\n\ndef generate(state):\n \"\"\"\n Generate answer\n\n Args:\n state (dict): The current graph state\n\n Returns:\n state (dict): New key added to state, generation, that contains LLM generation\n \"\"\"\n print(\"---GENERATE---\")\n question = state[\"question\"]\n documents = state[\"documents\"]\n\n # RAG generation\n generation = rag_chain.invoke({\"context\": documents, \"question\": question})\n return {\"documents\": documents, \"question\": question, \"generation\": generation}\n\n\ndef grade_documents(state):\n \"\"\"\n Determines whether the retrieved documents are relevant to the question.\n\n Args:\n state (dict): The current graph state\n\n Returns:\n state (dict): Updates documents key with only filtered relevant documents\n \"\"\"\n\n print(\"---CHECK DOCUMENT RELEVANCE TO QUESTION---\")\n question = state[\"question\"]\n documents = state[\"documents\"]\n\n # Score each doc\n filtered_docs = []\n for d in documents:\n score = retrieval_grader.invoke(\n {\"question\": question, \"document\": d.page_content}\n )\n grade = score.binary_score\n if grade == \"yes\":\n print(\"---GRADE: DOCUMENT RELEVANT---\")\n filtered_docs.append(d)\n else:\n print(\"---GRADE: DOCUMENT NOT RELEVANT---\")\n continue\n return {\"documents\": filtered_docs, \"question\": question}\n\n\ndef transform_query(state):\n \"\"\"\n Transform the query to produce a better question.\n\n Args:\n state (dict): The current graph state\n\n Returns:\n state (dict): Updates question key with a re-phrased question\n \"\"\"\n\n print(\"---TRANSFORM QUERY---\")\n question = state[\"question\"]\n documents = state[\"documents\"]\n\n # Re-write question\n better_question = question_rewriter.invoke({\"question\": question})\n return {\"documents\": documents, \"question\": better_question}" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "09fc91b4", + "metadata": {}, + "outputs": [], + "source": [ + "### Edges\n\n\ndef decide_to_generate(state):\n \"\"\"\n Determines whether to generate an answer, or re-generate a question.\n\n Args:\n state (dict): The current graph state\n\n Returns:\n str: Binary decision for next node to call\n \"\"\"\n\n print(\"---ASSESS GRADED DOCUMENTS---\")\n state[\"question\"]\n filtered_documents = state[\"documents\"]\n\n if not filtered_documents:\n # All documents have been filtered check_relevance\n # We will re-generate a new query\n print(\n \"---DECISION: ALL DOCUMENTS ARE NOT RELEVANT TO QUESTION, TRANSFORM QUERY---\"\n )\n return \"transform_query\"\n else:\n # We have relevant documents, so generate answer\n print(\"---DECISION: GENERATE---\")\n return \"generate\"\n\n\ndef grade_generation_v_documents_and_question(state):\n \"\"\"\n Determines whether the generation is grounded in the document and answers question.\n\n Args:\n state (dict): The current graph state\n\n Returns:\n str: Decision for next node to call\n \"\"\"\n\n print(\"---CHECK HALLUCINATIONS---\")\n question = state[\"question\"]\n documents = state[\"documents\"]\n generation = state[\"generation\"]\n\n score = hallucination_grader.invoke(\n {\"documents\": documents, \"generation\": generation}\n )\n grade = score.binary_score\n\n # Check hallucination\n if grade == \"yes\":\n print(\"---DECISION: GENERATION IS GROUNDED IN DOCUMENTS---\")\n # Check question-answering\n print(\"---GRADE GENERATION vs QUESTION---\")\n score = answer_grader.invoke({\"question\": question, \"generation\": generation})\n grade = score.binary_score\n if grade == \"yes\":\n print(\"---DECISION: GENERATION ADDRESSES QUESTION---\")\n return \"useful\"\n else:\n print(\"---DECISION: GENERATION DOES NOT ADDRESS QUESTION---\")\n return \"not useful\"\n else:\n pprint(\"---DECISION: GENERATION IS NOT GROUNDED IN DOCUMENTS, RE-TRY---\")\n return \"not supported\"" + ] + }, + { + "cell_type": "markdown", + "id": "61cd5797-1782-4d78-a277-8196d13f3e1b", + "metadata": {}, + "source": [ + "## Build Graph\n", + "\n", + "The just follows the flow we outlined in the figure above." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "0e09ca9f-e36d-4ef4-a0d5-79fdbada9fe0", + "metadata": {}, + "outputs": [], + "source": ["from langgraph.graph import END, StateGraph, START\n\nworkflow = StateGraph(GraphState)\n\n# Define the nodes\nworkflow.add_node(\"retrieve\", retrieve) # retrieve\nworkflow.add_node(\"grade_documents\", grade_documents) # grade documents\nworkflow.add_node(\"generate\", generate) # generate\nworkflow.add_node(\"transform_query\", transform_query) # transform_query\n\n# Build graph\nworkflow.add_edge(START, \"retrieve\")\nworkflow.add_edge(\"retrieve\", \"grade_documents\")\nworkflow.add_conditional_edges(\n \"grade_documents\",\n decide_to_generate,\n {\n \"transform_query\": \"transform_query\",\n \"generate\": \"generate\",\n },\n)\nworkflow.add_edge(\"transform_query\", \"retrieve\")\nworkflow.add_conditional_edges(\n \"generate\",\n grade_generation_v_documents_and_question,\n {\n \"not supported\": \"generate\",\n \"useful\": END,\n \"not useful\": \"transform_query\",\n },\n)\n\n# Compile\napp = workflow.compile()"] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "fb69dbb9-91ee-4868-8c3c-93af3cd885be", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---RETRIEVE---\n", + "\"Node 'retrieve':\"\n", + "'\\n---\\n'\n", + "---CHECK DOCUMENT RELEVANCE TO QUESTION---\n", + "---GRADE: DOCUMENT RELEVANT---\n", + "---GRADE: DOCUMENT RELEVANT---\n", + "---GRADE: DOCUMENT NOT RELEVANT---\n", + "---GRADE: DOCUMENT NOT RELEVANT---\n", + "---ASSESS GRADED DOCUMENTS---\n", + "---DECISION: GENERATE---\n", + "\"Node 'grade_documents':\"\n", + "'\\n---\\n'\n", + "---GENERATE---\n", + "---CHECK HALLUCINATIONS---\n", + "---DECISION: GENERATION IS GROUNDED IN DOCUMENTS---\n", + "---GRADE GENERATION vs QUESTION---\n", + "---DECISION: GENERATION ADDRESSES QUESTION---\n", + "\"Node 'generate':\"\n", + "'\\n---\\n'\n", + "'Daniel Craig stars as 007 in \"Skyfall\" (2012) and \"Spectre\" (2015).'\n" + ] + } + ], + "source": [ + "from pprint import pprint\n\n# Run\ninputs = {\"question\": \"Movies that star Daniel Craig\"}\nfor output in app.stream(inputs):\n for key, value in output.items():\n # Node\n pprint(f\"Node '{key}':\")\n pprint(\"\\n---\\n\")\n\n# Final generation\npprint(value[\"generation\"])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4138bc51-8c84-4b8a-8d24-f7f470721f6f", + "metadata": {}, + "outputs": [], + "source": [ + "inputs = {\"question\": \"Which movies are about aliens?\"}\nfor output in app.stream(inputs):\n for key, value in output.items():\n # Node\n pprint(f\"Node '{key}':\")\n pprint(\"\\n---\\n\")\n\n# Final generation\npprint(value[\"generation\"])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "42369ab8-322d-434a-b5dd-2266e4cb2903", + "metadata": {}, + "outputs": [], + "source": [ + "" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/react-agent-from-scratch.ipynb b/examples/react-agent-from-scratch.ipynb new file mode 100644 index 000000000..98514b13c --- /dev/null +++ b/examples/react-agent-from-scratch.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "294995c4", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/how-tos/react-agent-from-scratch.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/react-agent-structured-output.ipynb b/examples/react-agent-structured-output.ipynb new file mode 100644 index 000000000..180becb37 --- /dev/null +++ b/examples/react-agent-structured-output.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "40f0d107", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/how-tos/react-agent-structured-output.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/examples/recursion-limit.ipynb b/examples/recursion-limit.ipynb new file mode 100644 index 000000000..7d383f967 --- /dev/null +++ b/examples/recursion-limit.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "fa3f7c50", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/how-tos/recursion-limit.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/reflection/reflection.ipynb b/examples/reflection/reflection.ipynb new file mode 100644 index 000000000..4facaf3b4 --- /dev/null +++ b/examples/reflection/reflection.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "658773a2", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/tutorials/reflection/reflection.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/reflexion/reflexion.ipynb b/examples/reflexion/reflexion.ipynb new file mode 100644 index 000000000..71c21c5ff --- /dev/null +++ b/examples/reflexion/reflexion.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "caf07859", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/tutorials/reflexion/reflexion.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/rewoo/rewoo.ipynb b/examples/rewoo/rewoo.ipynb new file mode 100644 index 000000000..b5df4d0c6 --- /dev/null +++ b/examples/rewoo/rewoo.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "961f43ec", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/tutorials/rewoo/rewoo.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/run-id-langsmith.ipynb b/examples/run-id-langsmith.ipynb new file mode 100644 index 000000000..257c70c31 --- /dev/null +++ b/examples/run-id-langsmith.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "bbd6e9b8", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/how-tos/run-id-langsmith.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/examples/self-discover/self-discover.ipynb b/examples/self-discover/self-discover.ipynb new file mode 100644 index 000000000..0f0d6ad20 --- /dev/null +++ b/examples/self-discover/self-discover.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "f6db1873", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/tutorials/self-discover/self-discover.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/state-model.ipynb b/examples/state-model.ipynb new file mode 100644 index 000000000..7c6b27782 --- /dev/null +++ b/examples/state-model.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "4149ffcc", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/how-tos/state-model.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/storm/storm.ipynb b/examples/storm/storm.ipynb new file mode 100644 index 000000000..fc5088867 --- /dev/null +++ b/examples/storm/storm.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "3e05d7f9", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/tutorials/storm/storm.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.2" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/examples/stream-multiple.ipynb b/examples/stream-multiple.ipynb new file mode 100644 index 000000000..d55e6d6bb --- /dev/null +++ b/examples/stream-multiple.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "e663f597", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/how-tos/stream-multiple.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/stream-updates.ipynb b/examples/stream-updates.ipynb new file mode 100644 index 000000000..d7b86fc8c --- /dev/null +++ b/examples/stream-updates.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "e6829c80", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/how-tos/stream-updates.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/stream-values.ipynb b/examples/stream-values.ipynb new file mode 100644 index 000000000..c98939826 --- /dev/null +++ b/examples/stream-values.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "5ec11895", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/how-tos/stream-values.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/streaming-content.ipynb b/examples/streaming-content.ipynb new file mode 100644 index 000000000..5135bccd1 --- /dev/null +++ b/examples/streaming-content.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "6619387c", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/how-tos/streaming-content.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/streaming-events-from-within-tools-without-langchain.ipynb b/examples/streaming-events-from-within-tools-without-langchain.ipynb new file mode 100644 index 000000000..ce53577ce --- /dev/null +++ b/examples/streaming-events-from-within-tools-without-langchain.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "57b7e303", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/how-tos/streaming-events-from-within-tools-without-langchain.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/streaming-events-from-within-tools.ipynb b/examples/streaming-events-from-within-tools.ipynb new file mode 100644 index 000000000..66060a4fb --- /dev/null +++ b/examples/streaming-events-from-within-tools.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "8e71a0c8", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/how-tos/streaming-events-from-within-tools.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/streaming-from-final-node.ipynb b/examples/streaming-from-final-node.ipynb new file mode 100644 index 000000000..2f1142f30 --- /dev/null +++ b/examples/streaming-from-final-node.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "756e4554", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/how-tos/streaming-from-final-node.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/streaming-subgraphs.ipynb b/examples/streaming-subgraphs.ipynb new file mode 100644 index 000000000..83d94ba98 --- /dev/null +++ b/examples/streaming-subgraphs.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "47164a72", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/how-tos/streaming-subgraphs.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/streaming-tokens-without-langchain.ipynb b/examples/streaming-tokens-without-langchain.ipynb new file mode 100644 index 000000000..b16de62c6 --- /dev/null +++ b/examples/streaming-tokens-without-langchain.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "218dfbcb", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/how-tos/streaming-tokens-without-langchain.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/streaming-tokens.ipynb b/examples/streaming-tokens.ipynb new file mode 100644 index 000000000..46dd92dec --- /dev/null +++ b/examples/streaming-tokens.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "99eb887e", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/how-tos/streaming-tokens.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/subgraph-transform-state.ipynb b/examples/subgraph-transform-state.ipynb new file mode 100644 index 000000000..62e8d3781 --- /dev/null +++ b/examples/subgraph-transform-state.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "0de7689f", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/how-tos/subgraph-transform-state.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/examples/subgraph.ipynb b/examples/subgraph.ipynb new file mode 100644 index 000000000..7b3a31f55 --- /dev/null +++ b/examples/subgraph.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "f49876e1", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/how-tos/subgraph.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/examples/subgraphs-manage-state.ipynb b/examples/subgraphs-manage-state.ipynb new file mode 100644 index 000000000..113953122 --- /dev/null +++ b/examples/subgraphs-manage-state.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "5106959e", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/how-tos/subgraphs-manage-state.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/examples/tool-calling-errors.ipynb b/examples/tool-calling-errors.ipynb new file mode 100644 index 000000000..68628f21e --- /dev/null +++ b/examples/tool-calling-errors.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "dc21501d", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/how-tos/tool-calling-errors.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/examples/tool-calling.ipynb b/examples/tool-calling.ipynb new file mode 100644 index 000000000..882b45640 --- /dev/null +++ b/examples/tool-calling.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "7fd8bd65", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/how-tos/tool-calling.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/examples/tutorials/sql-agent.ipynb b/examples/tutorials/sql-agent.ipynb new file mode 100644 index 000000000..5227230c0 --- /dev/null +++ b/examples/tutorials/sql-agent.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "83c2223f", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/tutorials/sql-agent.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/tutorials/tnt-llm/tnt-llm.ipynb b/examples/tutorials/tnt-llm/tnt-llm.ipynb new file mode 100644 index 000000000..3c8421c29 --- /dev/null +++ b/examples/tutorials/tnt-llm/tnt-llm.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "11140167", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/tutorials/tnt-llm/tnt-llm.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/usaco/usaco.ipynb b/examples/usaco/usaco.ipynb new file mode 100644 index 000000000..7b83b7926 --- /dev/null +++ b/examples/usaco/usaco.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "9dffdb54", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/tutorials/usaco/usaco.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/visualization.ipynb b/examples/visualization.ipynb new file mode 100644 index 000000000..d4b383edc --- /dev/null +++ b/examples/visualization.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "9c9cb15a", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/how-tos/visualization.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/web-navigation/web_voyager.ipynb b/examples/web-navigation/web_voyager.ipynb new file mode 100644 index 000000000..2c1abdc0c --- /dev/null +++ b/examples/web-navigation/web_voyager.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "007ea2e9", + "metadata": {}, + "source": [ + "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/tutorials/web-navigation/web_voyager.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}