chatjs.langchain

chatjs.langchain

https://chatjs.langchain.com/

https://github.com/langchain-ai/chat-langchain

Chat LangChain

This repo is an implementation of a chatbot specifically focused on question answering over the LangChain documentation. Built with LangChain, LangGraph, and Next.js.

Deployed version: chat.langchain.com

Looking for the JS version? Click here.

The app leverages LangChain and LangGraph's streaming support and async API to update the page in real time for multiple users.

 

Technical description

There are two components: ingestion and question-answering.

Ingestion has the following steps:

1. Pull html from documentation site as well as the Github Codebase
2. Load html with LangChain's RecursiveURLLoader and SitemapLoader
3. Split documents with LangChain's RecursiveCharacterTextSplitter
4. Create a vectorstore of embeddings, using LangChain's Weaviate vectorstore wrapper (with OpenAI's embeddings).

Question-Answering has the following steps:

1. Given the chat history and new user input, determine what a standalone question would be using an LLM.
2. Given that standalone question, look up relevant documents from the vectorstore.
3. Pass the standalone question and relevant documents to the model to generate and stream the final answer.
4. Generate a trace URL for the current chat session, as well as the endpoint to collect feedback.

 

 

https://github.com/langchain-ai/chat-langchain/blob/master/backend/retrieval_graph/graph.py

"""Main entrypoint for the conversational retrieval graph.This module defines the core structure and functionality of the conversational
retrieval graph. It includes the main graph definition, state management,
and key functions for processing & routing user queries, generating research plans to answer user questions,
conducting research, and formulating responses.
"""from typing import Any, Literal, TypedDict, castfrom langchain_core.messages import BaseMessage
from langchain_core.runnables import RunnableConfig
from langgraph.graph import END, START, StateGraphfrom backend.retrieval_graph.configuration import AgentConfiguration
from backend.retrieval_graph.researcher_graph.graph import graph as researcher_graph
from backend.retrieval_graph.state import AgentState, InputState
from backend.utils import format_docs, load_chat_modelasync def create_research_plan(state: AgentState, *, config: RunnableConfig
) -> dict[str, list[str]]:"""Create a step-by-step research plan for answering a LangChain-related query.Args:state (AgentState): The current state of the agent, including conversation history.config (RunnableConfig): Configuration with the model used to generate the plan.Returns:dict[str, list[str]]: A dictionary with a 'steps' key containing the list of research steps."""class Plan(TypedDict):"""Generate research plan."""steps: list[str]configuration = AgentConfiguration.from_runnable_config(config)structured_output_kwargs = ({"method": "function_calling"} if "openai" in configuration.query_model else {})model = load_chat_model(configuration.query_model).with_structured_output(Plan, **structured_output_kwargs)messages = [{"role": "system", "content": configuration.research_plan_system_prompt}] + state.messagesresponse = cast(Plan, await model.ainvoke(messages, {"tags": ["langsmith:nostream"]}))return {"steps": response["steps"],"documents": "delete","query": state.messages[-1].content,}async def conduct_research(state: AgentState) -> dict[str, Any]:"""Execute the first step of the research plan.This function takes the first step from the research plan and uses it to conduct research.Args:state (AgentState): The current state of the agent, including the research plan steps.Returns:dict[str, list[str]]: A dictionary with 'documents' containing the research results and'steps' containing the remaining research steps.Behavior:- Invokes the researcher_graph with the first step of the research plan.- Updates the state with the retrieved documents and removes the completed step."""result = await researcher_graph.ainvoke({"question": state.steps[0]})return {"documents": result["documents"], "steps": state.steps[1:]}def check_finished(state: AgentState) -> Literal["respond", "conduct_research"]:"""Determine if the research process is complete or if more research is needed.This function checks if there are any remaining steps in the research plan:- If there are, route back to the `conduct_research` node- Otherwise, route to the `respond` nodeArgs:state (AgentState): The current state of the agent, including the remaining research steps.Returns:Literal["respond", "conduct_research"]: The next step to take based on whether research is complete."""if len(state.steps or []) > 0:return "conduct_research"else:return "respond"async def respond(state: AgentState, *, config: RunnableConfig
) -> dict[str, list[BaseMessage]]:"""Generate a final response to the user's query based on the conducted research.This function formulates a comprehensive answer using the conversation history and the documents retrieved by the researcher.Args:state (AgentState): The current state of the agent, including retrieved documents and conversation history.config (RunnableConfig): Configuration with the model used to respond.Returns:dict[str, list[str]]: A dictionary with a 'messages' key containing the generated response."""configuration = AgentConfiguration.from_runnable_config(config)model = load_chat_model(configuration.response_model)# TODO: add a re-ranker heretop_k = 20context = format_docs(state.documents[:top_k])response = await model.ainvoke([{"role": "system","content": configuration.response_system_prompt.format(context=context),},*state.messages,])return {"messages": [response], "answer": response.content}# Define the graph

builder = StateGraph(AgentState, input=InputState, config_schema=AgentConfiguration)
builder.add_node(create_research_plan)
builder.add_node(conduct_research)
builder.add_node(respond)builder.add_edge(START, "create_research_plan")
builder.add_edge("create_research_plan", "conduct_research")
builder.add_conditional_edges("conduct_research", check_finished)
builder.add_edge("respond", END)# Compile into a graph object that you can invoke and deploy.
graph = builder.compile()
graph.name = "RetrievalGraph"