%pip install langfuse langchain langgraph langchain_openai langchain_community

import os# Get keys for your project from the project settings page: https://cloud.langfuse.comos.environ["LANGFUSE_PUBLIC_KEY"]= "pk-lf-..."os.environ["LANGFUSE_SECRET_KEY"]= "sk-lf-..."os.environ["LANGFUSE_HOST"]= "https://cloud.langfuse.com" # 🇪🇺 EU region# os.environ["LANGFUSE_HOST"] = "https://us.cloud.langfuse.com" # 🇺🇸 US region# Your openai keyos.environ["OPENAI_API_KEY"]= "sk-proj-..."

from langfuseimport get_clientlangfuse= get_client()# Verify connectionif langfuse.auth_check():    print("Langfuse client is authenticated and ready!")else:    print("Authentication failed. Please check your credentials and host.")

from typingimport Annotatedfrom langchain_openaiimport ChatOpenAIfrom langchain_core.messagesimport HumanMessagefrom typing_extensionsimport TypedDictfrom langgraph.graphimport StateGraphfrom langgraph.graph.messageimport add_messagesclass State(TypedDict):    # Messages have the type "list". The `add_messages` function in the annotation defines how this state key should be updated    # (in this case, it appends messages to the list, rather than overwriting them)    messages: Annotated[list, add_messages]graph_builder= StateGraph(State)llm= ChatOpenAI(model = "gpt-4o",temperature = 0.2)# The chatbot node function takes the current State as input and returns an updated messages list. This is the basic pattern for all LangGraph node functions.def chatbot(state: State):    return {"messages": [llm.invoke(state["messages"])]}# Add a "chatbot" node. Nodes represent units of work. They are typically regular python functions.graph_builder.add_node("chatbot", chatbot)# Add an entry point. This tells our graph where to start its work each time we run it.graph_builder.set_entry_point("chatbot")# Set a finish point. This instructs the graph "any time this node is run, you can exit."graph_builder.set_finish_point("chatbot")# To be able to run our graph, call "compile()" on the graph builder. This creates a "CompiledGraph" we can use invoke on our state.graph= graph_builder.compile()

from langfuse.langchainimport CallbackHandler# Initialize Langfuse CallbackHandler for Langchain (tracing)langfuse_handler= CallbackHandler()for sin graph.stream({"messages": [HumanMessage(content = "What is Langfuse?")]},                      config={"callbacks": [langfuse_handler]}):    print(s)

from IPython.displayimport Image, displaydisplay(Image(graph.get_graph().draw_mermaid_png()))

from typingimport Annotatedfrom langchain_openaiimport ChatOpenAIfrom typing_extensionsimport TypedDictfrom langgraph.graphimport StateGraphfrom langgraph.graph.messageimport add_messagesfrom langfuse.langchainimport CallbackHandlerclass State(TypedDict):  messages: Annotated[list, add_messages]graph_builder= StateGraph(State)llm= ChatOpenAI(model = "gpt-4o",temperature = 0.2)def chatbot(state: State):  return {"messages": [llm.invoke(state["messages"])]}graph_builder.add_node("chatbot", chatbot)graph_builder.set_entry_point("chatbot")graph_builder.set_finish_point("chatbot")# Initialize Langfuse CallbackHandler for Langchain (tracing)langfuse_handler= CallbackHandler()# Call "with_config" from the compiled graph.# It returns a "CompiledGraph", similar to "compile", but with callbacks included.# This enables automatic graph tracing without needing to add callbacks manually every time.graph= graph_builder.compile().with_config({"callbacks": [langfuse_handler]})

%pip install langfuse langgraph langchain langchain_openai langchain_experimental pandas wikipedia

from typingimport Annotatedfrom langchain_community.toolsimport WikipediaQueryRunfrom langchain_community.utilitiesimport WikipediaAPIWrapperfrom datetimeimport datetimefrom langchain.toolsimport Tool# Define a tools that searches Wikipediawikipedia_tool= WikipediaQueryRun(api_wrapper=WikipediaAPIWrapper())# Define a new tool that returns the current datetimedatetime_tool= Tool(    name="Datetime",    func = lambda x: datetime.now().isoformat(),    description="Returns the current datetime",)

from langchain.agentsimport AgentExecutor, create_openai_tools_agentfrom langchain_core.messagesimport BaseMessage, HumanMessagefrom langchain_openaiimport ChatOpenAIdef create_agent(llm: ChatOpenAI, system_prompt:str, tools:list):    # Each worker node will be given a name and some tools.    prompt= ChatPromptTemplate.from_messages(        [            (                "system",                system_prompt,            ),            MessagesPlaceholder(variable_name="messages"),            MessagesPlaceholder(variable_name="agent_scratchpad"),        ]    )    agent= create_openai_tools_agent(llm, tools, prompt)    executor= AgentExecutor(agent=agent,tools=tools)    return executordef agent_node(state, agent, name):    result= agent.invoke(state)    return {"messages": [HumanMessage(content=result["output"],name=name)]}

from langchain_core.output_parsers.openai_functionsimport JsonOutputFunctionsParserfrom langchain_core.promptsimport ChatPromptTemplate, MessagesPlaceholdermembers= ["Researcher","CurrentTime"]system_prompt= (    "You are a supervisor tasked with managing a conversation between the"    " following workers:{members}. Given the following user request,"    " respond with the worker to act next. Each worker will perform a"    " task and respond with their results and status. When finished,"    " respond with FINISH.")# Our team supervisor is an LLM node. It just picks the next agent to process and decides when the work is completedoptions= ["FINISH"]+ members# Using openai function calling can make output parsing easier for usfunction_def= {    "name":"route",    "description":"Select the next role.",    "parameters": {        "title":"routeSchema",        "type":"object",        "properties": {            "next": {                "title":"Next",                "anyOf": [                    {"enum": options},                ],            }        },        "required": ["next"],    },}# Create the prompt using ChatPromptTemplateprompt= ChatPromptTemplate.from_messages(    [        ("system", system_prompt),        MessagesPlaceholder(variable_name="messages"),        (            "system",            "Given the conversation above, who should act next?"            " Or should we FINISH? Select one of:{options}",        ),    ]).partial(options=str(options),members=", ".join(members))llm= ChatOpenAI(model="gpt-4o")# Construction of the chain for the supervisor agentsupervisor_chain= (    prompt    | llm.bind_functions(functions=[function_def],function_call="route")    | JsonOutputFunctionsParser())

import functoolsimport operatorfrom typingimport Sequence, TypedDictfrom langchain_core.promptsimport ChatPromptTemplate, MessagesPlaceholderfrom langgraph.graphimport END, StateGraph,START# The agent state is the input to each node in the graphclass AgentState(TypedDict):    # The annotation tells the graph that new messages will always be added to the current states    messages: Annotated[Sequence[BaseMessage], operator.add]    # The 'next' field indicates where to route to next    next:str# Add the research agent using the create_agent helper functionresearch_agent= create_agent(llm,"You are a web researcher.", [wikipedia_tool])research_node= functools.partial(agent_node,agent=research_agent,name="Researcher")# Add the time agent using the create_agent helper functioncurrenttime_agent= create_agent(llm,"You can tell the current time at", [datetime_tool])currenttime_node= functools.partial(agent_node,agent=currenttime_agent,name = "CurrentTime")workflow= StateGraph(AgentState)# Add a "chatbot" node. Nodes represent units of work. They are typically regular python functions.workflow.add_node("Researcher", research_node)workflow.add_node("CurrentTime", currenttime_node)workflow.add_node("supervisor", supervisor_chain)# We want our workers to ALWAYS "report back" to the supervisor when donefor memberin members:    workflow.add_edge(member,"supervisor")# Conditional edges usually contain "if" statements to route to different nodes depending on the current graph state.# These functions receive the current graph state and return a string or list of strings indicating which node(s) to call next.conditional_map= {k: kfor kin members}conditional_map["FINISH"]= ENDworkflow.add_conditional_edges("supervisor",lambda x: x["next"], conditional_map)# Add an entry point. This tells our graph where to start its work each time we run it.workflow.add_edge(START,"supervisor")# To be able to run our graph, call "compile()" on the graph builder. This creates a "CompiledGraph" we can use invoke on our state.graph_2= workflow.compile()

from langfuse.langchainimport CallbackHandler# Initialize Langfuse CallbackHandler for Langchain (tracing)langfuse_handler= CallbackHandler()# Add Langfuse handler as callback: config={"callbacks": [langfuse_handler]}# You can also set an optional 'run_name' that will be used as the trace name in Langfusefor sin graph_2.stream({"messages": [HumanMessage(content = "How does photosynthesis work?")]},                      config={"callbacks": [langfuse_handler]}):    print(s)    print("----")

# Add Langfuse handler as callback: config={"callbacks": [langfuse_handler]}for sin graph_2.stream({"messages": [HumanMessage(content = "What time is it?")]},                      config={"callbacks": [langfuse_handler]}):    print(s)    print("----")

from IPython.displayimport Image, displaydisplay(Image(graph_2.get_graph().draw_mermaid_png()))

from langfuseimport get_client, Langfusefrom langfuse.langchainimport CallbackHandlerlangfuse= get_client()# Generate deterministic trace ID from external systempredefined_trace_id= Langfuse.create_trace_id()# Initialize Langfuse CallbackHandler for Langchain (tracing)langfuse_handler= CallbackHandler()

from typingimport Annotatedfrom langchain_openaiimport ChatOpenAIfrom langchain_core.messagesimport HumanMessagefrom typing_extensionsimport TypedDictfrom langgraph.graphimport StateGraphfrom langgraph.graph.messageimport add_messagesclass State(TypedDict):    messages: Annotated[list, add_messages]graph_builder= StateGraph(State)llm= ChatOpenAI(model = "gpt-4o",temperature = 0.2)def chatbot(state: State):    return {"messages": [llm.invoke(state["messages"])]}graph_builder.add_node("chatbot", chatbot)graph_builder.set_entry_point("chatbot")graph_builder.set_finish_point("chatbot")sub_agent= graph_builder.compile()

from langchain_core.toolsimport tool@tooldef langgraph_research(question):  """Conducts research for various topics."""  with langfuse.start_as_current_span(      name="🤖-sub-research-agent",      trace_context={"trace_id": predefined_trace_id}  )as span:      span.update_trace(input=question)      response= sub_agent.invoke({"messages": [HumanMessage(content = question)]},                        config={"callbacks": [langfuse_handler]})      span.update_trace(output= response["messages"][1].content)  return response["messages"][1].content

from langgraph.prebuiltimport create_react_agentfrom langchain_openaiimport ChatOpenAIllm= ChatOpenAI(model = "gpt-4o",temperature = 0.2)main_agent= create_react_agent(    model=llm,    tools=[langgraph_research])

user_question= "What is Langfuse?"# Use the predefined trace ID with trace_contextwith langfuse.start_as_current_span(    name="🤖-main-agent",    trace_context={"trace_id": predefined_trace_id})as span:    span.update_trace(input=user_question)    # LangChain execution will be part of this trace    response= main_agent.invoke({"messages": [{"role":"user","content": user_question}]},                            config={"callbacks": [langfuse_handler]})    span.update_trace(output=response["messages"][1].content)print(f"Trace ID:{predefined_trace_id}")# Use this for scoring later

from langfuseimport get_clientlangfuse= get_client()# Option 1: Use the yielded span object from the context managerwith langfuse.start_as_current_span(    name="langgraph-request")as span:    # ... LangGraph execution ...    # Score using the span object    span.score_trace(        name="user-feedback",        value=1,        data_type="NUMERIC",        comment="This was correct, thank you"    )# Option 2: Use langfuse.score_current_trace() if still in contextwith langfuse.start_as_current_span(name="langgraph-request")as span:    # ... LangGraph execution ...    # Score using current context    langfuse.score_current_trace(        name="user-feedback",        value=1,        data_type="NUMERIC"    )# Option 3: Use create_score() with trace ID (when outside context)langfuse.create_score(    trace_id=predefined_trace_id,    name="user-feedback",    value=1,    data_type="NUMERIC",    comment="This was correct, thank you")

from langfuseimport get_clientlangfuse= get_client()langfuse.create_prompt(    name="translator_system-prompt",    prompt="You are a translator that translates every input text into Spanish.",    labels=["production"])

# Get current production version of prompt and transform the Langfuse prompt into a string that can be used in Langchainlangfuse_system_prompt= langfuse.get_prompt("translator_system-prompt")langchain_system_prompt= langfuse_system_prompt.get_langchain_prompt()print(langchain_system_prompt)

from typingimport Annotatedfrom langchain_openaiimport ChatOpenAIfrom typing_extensionsimport TypedDictfrom langgraph.graphimport StateGraphfrom langgraph.graph.messageimport add_messagesclass State(TypedDict):    messages: Annotated[list, add_messages]graph_builder= StateGraph(State)llm= ChatOpenAI(model = "gpt-4o",temperature = 0.2)# Add the system prompt for our translator assistentsystem_prompt= {    "role":"system",    "content": langchain_system_prompt}def chatbot(state: State):    messages_with_system_prompt= [system_prompt]+ state["messages"]    response= llm.invoke(messages_with_system_prompt)    return {"messages": [response]}graph_builder.add_node("chatbot", chatbot)graph_builder.set_entry_point("chatbot")graph_builder.set_finish_point("chatbot")graph= graph_builder.compile()

from langfuse.langchainimport CallbackHandler# Initialize Langfuse CallbackHandler for Langchain (tracing)langfuse_handler= CallbackHandler()# Add Langfuse handler as callback: config={"callbacks": [langfuse_handler]}for sin graph.stream({"messages": [HumanMessage(content = "What is Langfuse?")]},                      config={"callbacks": [langfuse_handler]}):    print(s)