LangChain

pip install rdk langchain-anthropic langchain-openai --extra-index-url https://pypi.fury.io/021labs/

from langchain_anthropic import ChatAnthropic
from rdk import observe, shutdown

@observe(name="langchain-chat")
def chat(message: str) -> str:
    llm = ChatAnthropic(model="claude-sonnet-4-6")
    response = llm.invoke(message)
    return response.content

result = chat("Explain the theory of relativity")
print(result)

shutdown()

from langchain_anthropic import ChatAnthropic
from langchain_core.messages import HumanMessage, ToolMessage
from langchain_core.tools import tool
from rdk import observe, shutdown

@tool
def search(query: str) -> str:
    """Search the web for information."""
    return f"Results for: {query}"

@tool
def calculate(expression: str) -> str:
    """Evaluate a math expression."""
    return str(eval(expression))

tools = [search, calculate]
tool_map = {t.name: t for t in tools}

@observe(name="langchain-agent")
def agent(question: str) -> str:
    llm = ChatAnthropic(model="claude-sonnet-4-6")
    llm_with_tools = llm.bind_tools(tools)

    messages = [HumanMessage(content=question)]

    for _ in range(5):  # Max iterations
        response = llm_with_tools.invoke(messages)
        messages.append(response)

        if not response.tool_calls:
            return response.content

        for tc in response.tool_calls:
            result = tool_map[tc["name"]].invoke(tc["args"])
            messages.append(ToolMessage(
                content=result,
                tool_call_id=tc["id"]
            ))

    return "Max iterations reached"

result = agent("What is 25 * 4 + 100?")
shutdown()

import asyncio
from langchain_anthropic import ChatAnthropic
from rdk import observe, shutdown

@observe(name="async-langchain")
async def async_chat(message: str) -> str:
    llm = ChatAnthropic(model="claude-sonnet-4-6")
    response = await llm.ainvoke(message)
    return response.content

result = asyncio.run(async_chat("Hello!"))
shutdown()

from langchain_anthropic import ChatAnthropic
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from rdk import observe, shutdown

@observe(name="translation-chain")
def translate(text: str, target_lang: str) -> str:
    prompt = ChatPromptTemplate.from_template(
        "Translate this to {language}: {text}"
    )
    llm = ChatAnthropic(model="claude-sonnet-4-6")
    parser = StrOutputParser()

    chain = prompt | llm | parser
    return chain.invoke({"text": text, "language": target_lang})

result = translate("Hello world", "French")
shutdown()