@langwatch/mcp-server 0.7.0 → 0.8.0

package/tests/fixtures/langchain/langchain_rag_bot_vertex_ai_expected.py

@@ -1,116 +0,0 @@
-import json
-import os
-import tempfile
-from dotenv import load_dotenv
-
-from langwatch.types import RAGChunk
-
-load_dotenv()
-
-import chainlit as cl
-from langchain.prompts import ChatPromptTemplate
-from langchain.schema import HumanMessage
-from langchain.schema.runnable.config import RunnableConfig
-
-import langwatch
-
-from langchain_community.document_loaders import WebBaseLoader
-from langchain_community.vectorstores.faiss import FAISS
-from langchain_openai import ChatOpenAI, OpenAIEmbeddings
-from langchain_text_splitters import RecursiveCharacterTextSplitter
-from langchain.tools.retriever import create_retriever_tool
-from langchain.agents import AgentExecutor, create_tool_calling_agent
-from langchain.tools import BaseTool, StructuredTool, tool
-from langchain_google_vertexai import ChatVertexAI, VertexAI
-
-loader = WebBaseLoader("https://docs.langwatch.ai")
-docs = loader.load()
-documents = RecursiveCharacterTextSplitter(
-    chunk_size=1000, chunk_overlap=200
-).split_documents(docs)
-vector = FAISS.from_documents(documents, OpenAIEmbeddings())
-retriever = vector.as_retriever()
-
-
-@cl.on_chat_start
-async def on_chat_start():
-    retriever_tool = create_retriever_tool(
-        langwatch.langchain.capture_rag_from_retriever(
-            retriever,
-            lambda document: RAGChunk(
-                document_id=document.metadata["source"], content=document.page_content
-            ),
-        ),
-        "langwatch_search",
-        "Search for information about LangWatch. For any questions about LangWatch, use this tool if you didn't already",
-    )
-
-    # Alternative approach to retrievers
-    # wrapped_tool = langwatch.langchain.capture_rag_from_tool(
-    #     retriever_tool, lambda response: [RAGChunk(content=response)]
-    # )
-
-    try:
-        credentials_json = json.loads(os.environ["GOOGLE_APPLICATION_CREDENTIALS"])
-        credentials_file = tempfile.NamedTemporaryFile(mode="w", delete=False)
-        credentials_file.write(json.dumps(credentials_json))
-        credentials_file.close()
-
-        os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = credentials_file.name
-    except:
-        pass
-
-    tools = [retriever_tool]
-    model = ChatVertexAI(
-        model_name="gemini-1.5-flash-001",
-        project=os.environ["VERTEXAI_PROJECT"],
-        location=os.environ["VERTEXAI_LOCATION"],
-        streaming=True,
-    )
-    prompt = ChatPromptTemplate.from_messages(
-        [
-            (
-                "system",
-                "You are a helpful assistant that only reply in short tweet-like responses, using lots of emojis and use tools only once.\n\n{agent_scratchpad}",
-            ),
-            ("human", "{question}"),
-        ]
-    )
-    agent = create_tool_calling_agent(model, tools, prompt)
-    executor = AgentExecutor(agent=agent, tools=tools, verbose=True)  # type: ignore
-    cl.user_session.set("agent", executor)
-
-
-@cl.on_message
-@langwatch.trace()
-async def main(message: cl.Message):
-    agent: AgentExecutor = cl.user_session.get("agent")  # type: ignore
-
-    msg = cl.Message(content="")
-
-    langwatch.get_current_trace().update(
-        metadata={"customer_id": "customer_example", "labels": ["langchain", "rag", "vertex_ai"]}
-    )
-
-    async for chunk in agent.astream(
-        {
-            "question": message.content,
-            "messages": [HumanMessage(content="Hoi, dit is een test")],
-        },
-        config=RunnableConfig(
-            callbacks=[
-                cl.LangchainCallbackHandler(),
-                langwatch.get_current_trace().get_langchain_callback(),
-            ]
-        ),
-    ):
-        if "output" in chunk:
-            await msg.stream_token(chunk["output"])
-        elif "actions" in chunk:
-            await msg.stream_token(chunk["actions"][0].log)
-        elif "steps" in chunk:
-            await msg.stream_token(chunk["steps"][0].observation + "\n\n")
-        else:
-            await msg.stream_token("<unammaped chunk>")
-
-    await msg.send()

package/tests/fixtures/langchain/langchain_rag_bot_vertex_ai_input.py

@@ -1,81 +0,0 @@
-import json
-import os
-import tempfile
-from dotenv import load_dotenv
-
-load_dotenv()
-
-import chainlit as cl
-from langchain.prompts import ChatPromptTemplate
-from langchain.schema import HumanMessage
-from langchain.schema.runnable.config import RunnableConfig
-
-from langchain_community.document_loaders import WebBaseLoader
-from langchain_community.vectorstores.faiss import FAISS
-from langchain_openai import ChatOpenAI, OpenAIEmbeddings
-from langchain_text_splitters import RecursiveCharacterTextSplitter
-from langchain.tools.retriever import create_retriever_tool
-from langchain.agents import AgentExecutor, create_tool_calling_agent
-from langchain.tools import BaseTool, StructuredTool, tool
-from langchain_google_vertexai import ChatVertexAI, VertexAI
-
-loader = WebBaseLoader("https://docs.langwatch.ai")
-docs = loader.load()
-documents = RecursiveCharacterTextSplitter(
-    chunk_size=1000, chunk_overlap=200
-).split_documents(docs)
-vector = FAISS.from_documents(documents, OpenAIEmbeddings())
-retriever = vector.as_retriever()
-
-
-@cl.on_chat_start
-async def on_chat_start():
-    retriever_tool = create_retriever_tool(
-        retriever,
-        "langwatch_search",
-        "Search for information about LangWatch. For any questions about LangWatch, use this tool if you didn't already",
-    )
-
-    tools = [retriever_tool]
-    model = ChatVertexAI(model="gemini-pro", streaming=True)
-    prompt = ChatPromptTemplate.from_messages(
-        [
-            (
-                "system",
-                "You are a helpful assistant that only reply in short tweet-like responses, using lots of emojis and use tools only once.\n\n{agent_scratchpad}",
-            ),
-            ("human", "{question}"),
-        ]
-    )
-    agent = create_tool_calling_agent(model, tools, prompt)
-    executor = AgentExecutor(agent=agent, tools=tools, verbose=True)  # type: ignore
-    cl.user_session.set("agent", executor)
-
-
-@cl.on_message
-async def main(message: cl.Message):
-    agent: AgentExecutor = cl.user_session.get("agent")  # type: ignore
-
-    msg = cl.Message(content="")
-
-    async for chunk in agent.astream(
-        {
-            "question": message.content,
-            "messages": [HumanMessage(content="Hoi, dit is een test")],
-        },
-        config=RunnableConfig(
-            callbacks=[
-                cl.LangchainCallbackHandler(),
-            ]
-        ),
-    ):
-        if "output" in chunk:
-            await msg.stream_token(chunk["output"])
-        elif "actions" in chunk:
-            await msg.stream_token(chunk["actions"][0].log)
-        elif "steps" in chunk:
-            await msg.stream_token(chunk["steps"][0].observation + "\n\n")
-        else:
-            await msg.stream_token("<unammaped chunk>")
-
-    await msg.send()

package/tests/fixtures/langchain/langgraph_rag_bot_with_threads_expected.py

@@ -1,331 +0,0 @@
-import os
-
-os.environ["CHAINLIT_AUTH_SECRET"] = (
-    "sSgdH4IfqM/%5swBnuwNdZ8rS/VBDW-WiBF?>DW_YPPKm9p9CiO6PPm6Z4Ih7IL"
-)
-
-import datetime
-import os.path
-import pickle
-from typing import Dict, List, Literal, Optional
-from dotenv import load_dotenv
-
-from langwatch.types import RAGChunk
-
-load_dotenv()
-
-import chainlit as cl
-from langchain.prompts import ChatPromptTemplate
-from langchain.schema import HumanMessage
-from langchain.schema.runnable.config import RunnableConfig
-
-import langwatch
-
-from langchain_community.document_loaders import WebBaseLoader
-from langchain_community.vectorstores.faiss import FAISS
-from langchain_openai import ChatOpenAI, OpenAIEmbeddings
-from langchain_text_splitters import RecursiveCharacterTextSplitter
-from langchain.tools.retriever import create_retriever_tool
-from langchain.agents import AgentExecutor, create_tool_calling_agent
-from langchain.tools import BaseTool, StructuredTool, tool
-import chainlit as cl
-import chainlit.data as cl_data
-from chainlit.data.utils import queue_until_user_message
-from chainlit.element import Element, ElementDict
-from chainlit.socket import persist_user_session
-from chainlit.step import StepDict
-from chainlit.types import (
-    Feedback,
-    PageInfo,
-    PaginatedResponse,
-    Pagination,
-    ThreadDict,
-    ThreadFilter,
-)
-from langgraph.graph import StateGraph, START, END, MessagesState
-from langgraph.prebuilt import ToolNode
-from langgraph.graph.state import CompiledStateGraph
-
-loader = WebBaseLoader("https://docs.langwatch.ai")
-docs = loader.load()
-documents = RecursiveCharacterTextSplitter(
-    chunk_size=1000, chunk_overlap=200
-).split_documents(docs)
-vector = FAISS.from_documents(documents, OpenAIEmbeddings())
-retriever = vector.as_retriever()
-
-
-now = datetime.datetime.now()
-
-thread_history = [
-    {
-        "id": "test1",
-        "name": "thread 1",
-        "createdAt": now,
-        "userId": "test",
-        "userIdentifier": "admin",
-        "steps": [
-            {
-                "id": "test1",
-                "name": "test",
-                "createdAt": now,
-                "type": "user_message",
-                "output": "Message 1",
-            },
-            {
-                "id": "test2",
-                "name": "test",
-                "createdAt": now,
-                "type": "assistant_message",
-                "output": "Message 2",
-            },
-        ],
-    },
-    {
-        "id": "test2",
-        "createdAt": now,
-        "userId": "test",
-        "userIdentifier": "admin",
-        "name": "thread 2",
-        "steps": [
-            {
-                "id": "test3",
-                "createdAt": now,
-                "name": "test",
-                "type": "user_message",
-                "output": "Message 3",
-            },
-            {
-                "id": "test4",
-                "createdAt": now,
-                "name": "test",
-                "type": "assistant_message",
-                "output": "Message 4",
-            },
-        ],
-    },
-]
-deleted_thread_ids = []
-
-THREAD_HISTORY_PICKLE_PATH = os.getenv("THREAD_HISTORY_PICKLE_PATH")
-if THREAD_HISTORY_PICKLE_PATH and os.path.exists(THREAD_HISTORY_PICKLE_PATH):
-    with open(THREAD_HISTORY_PICKLE_PATH, "rb") as f:
-        thread_history = pickle.load(f)
-
-
-async def save_thread_history():
-    if THREAD_HISTORY_PICKLE_PATH:
-        # Force saving of thread history for reload when server restarts
-        await persist_user_session(
-            cl.context.session.thread_id, cl.context.session.to_persistable()
-        )
-
-        with open(THREAD_HISTORY_PICKLE_PATH, "wb") as out_file:
-            pickle.dump(thread_history, out_file)
-
-
-class TestDataLayer(cl_data.base.BaseDataLayer):
-    async def get_user(self, identifier: str):
-        return cl.PersistedUser(
-            id="test", createdAt=now.isoformat(), identifier=identifier
-        )
-
-    async def create_user(self, user: cl.User):
-        return cl.PersistedUser(
-            id="test", createdAt=now.isoformat(), identifier=user.identifier
-        )
-
-    async def update_thread(
-        self,
-        thread_id: str,
-        name: Optional[str] = None,
-        user_id: Optional[str] = None,
-        metadata: Optional[Dict] = None,
-        tags: Optional[List[str]] = None,
-    ):
-        thread = next((t for t in thread_history if t["id"] == thread_id), None)
-        if thread:
-            if name:
-                thread["name"] = name
-            if metadata:
-                thread["metadata"] = metadata
-            if tags:
-                thread["tags"] = tags
-        else:
-            thread_history.append(
-                {
-                    "id": thread_id,
-                    "name": name,
-                    "metadata": metadata,
-                    "tags": tags,
-                    "createdAt": now.isoformat(),
-                    "userId": user_id,
-                    "userIdentifier": "admin",
-                    "steps": [],
-                }
-            )
-
-    @cl_data.queue_until_user_message()
-    async def create_step(self, step_dict: StepDict):
-        thread = next(
-            (t for t in thread_history if t["id"] == step_dict.get("threadId")), None
-        )
-        if thread:
-            thread["steps"].append(step_dict)
-
-    async def get_thread_author(self, thread_id: str):
-        return "admin"
-
-    async def list_threads(
-        self, pagination: Pagination, filters: ThreadFilter
-    ) -> PaginatedResponse[ThreadDict]:
-        return PaginatedResponse(
-            data=[t for t in thread_history if t["id"] not in deleted_thread_ids],
-            pageInfo=PageInfo(hasNextPage=False, startCursor=None, endCursor=None),
-        )  # type: ignore
-
-    async def get_thread(self, thread_id: str):
-        thread = next((t for t in thread_history if t["id"] == thread_id), None)
-        if not thread:
-            return None
-        thread["steps"] = sorted(thread["steps"], key=lambda x: x["createdAt"])
-        return thread
-
-    async def delete_thread(self, thread_id: str):
-        deleted_thread_ids.append(thread_id)
-
-    async def delete_feedback(
-        self,
-        feedback_id: str,
-    ) -> bool:
-        return True
-
-    async def upsert_feedback(
-        self,
-        feedback: Feedback,
-    ) -> str:
-        return ""
-
-    @queue_until_user_message()
-    async def create_element(self, element: "Element"):
-        pass
-
-    async def get_element(
-        self, thread_id: str, element_id: str
-    ) -> Optional["ElementDict"]:
-        pass
-
-    @queue_until_user_message()
-    async def delete_element(self, element_id: str, thread_id: Optional[str] = None):
-        pass
-
-    @queue_until_user_message()
-    async def update_step(self, step_dict: "StepDict"):
-        pass
-
-    @queue_until_user_message()
-    async def delete_step(self, step_id: str):
-        pass
-
-    async def build_debug_url(self) -> str:
-        return ""
-
-
-cl_data._data_layer = TestDataLayer()
-
-
-retriever_tool = create_retriever_tool(
-    langwatch.langchain.capture_rag_from_retriever(
-        retriever,
-        lambda document: RAGChunk(
-            document_id=document.metadata["source"], content=document.page_content
-        ),
-    ),
-    "langwatch_search",
-    "Search for information about LangWatch. For any questions about LangWatch, use this tool if you didn't already",
-)
-
-tools = [retriever_tool]
-tool_node = ToolNode(tools)
-model = ChatOpenAI(streaming=True).bind_tools(tools)
-
-
-def should_continue(state: MessagesState):
-    messages = state["messages"]
-    last_message = messages[-1]
-    # If the LLM makes a tool call, then we route to the "tools" node
-    if last_message.tool_calls:  # type: ignore
-        return "tools"
-    return END
-
-
-def call_model(state):
-    messages = state["messages"]
-    response = model.invoke(messages)
-    # We return a list, because this will get added to the existing list
-    return {"messages": [response]}
-
-
-# Define the graph
-workflow = StateGraph(MessagesState)
-
-workflow.add_node("agent", call_model)
-workflow.add_node("tools", tool_node)
-
-workflow.add_edge(START, "agent")
-workflow.add_conditional_edges("agent", should_continue)
-workflow.add_edge("tools", "agent")
-
-# Compile the graph
-app = workflow.compile()
-
-
-@cl.on_message
-@langwatch.trace()
-async def main(message: cl.Message):
-    msg = cl.Message(content="")
-
-    langwatch.get_current_trace().update(
-        metadata={
-            "labels": ["langchain", "rag", "tools"],
-            "user_id": getattr(cl.user_session.get("user"), "identifier", "unknown"),
-            "thread_id": cl.context.session.thread_id,
-        }
-    )
-
-    async for event in app.astream(
-        {"messages": [HumanMessage(content=message.content)]},
-        config=RunnableConfig(
-            callbacks=[
-                cl.LangchainCallbackHandler(),
-                langwatch.get_current_trace().get_langchain_callback(),
-            ]
-        ),
-    ):
-        if "agent" in event:
-            if "messages" in event["agent"]:
-                for message in event["agent"]["messages"]:
-                    await msg.stream_token(message.content)
-
-    await msg.send()
-
-    await save_thread_history()
-
-
-@cl.password_auth_callback
-async def auth_callback(username: str, password: str) -> Optional[cl.User]:
-    if (username, password) == ("admin", "admin"):
-        return cl.User(identifier="admin")
-    else:
-        return None
-
-
-@cl.on_chat_resume
-async def on_chat_resume(thread: ThreadDict):
-    await cl.Message(f"Welcome back to {thread['name']}").send()
-    if "metadata" in thread and thread["metadata"]:
-        await cl.Message(thread["metadata"], author="metadata", language="json").send()
-    if "tags" in thread and thread["tags"]:
-        await cl.Message(
-            ",".join(thread["tags"]), author="tags", language="json"
-        ).send()

package/tests/fixtures/langchain/langgraph_rag_bot_with_threads_input.py

@@ -1,106 +0,0 @@
-import os
-
-os.environ["CHAINLIT_AUTH_SECRET"] = (
-    "sSgdH4IfqM/%5swBnuwNdZ8rS/VBDW-WiBF?>DW_YPPKm9p9CiO6PPm6Z4Ih7IL"
-)
-
-import datetime
-import os.path
-import pickle
-from typing import Dict, List, Literal, Optional
-from dotenv import load_dotenv
-
-load_dotenv()
-
-import chainlit as cl
-from langchain.prompts import ChatPromptTemplate
-from langchain.schema import HumanMessage
-from langchain.schema.runnable.config import RunnableConfig
-
-from langchain_community.document_loaders import WebBaseLoader
-from langchain_community.vectorstores.faiss import FAISS
-from langchain_openai import ChatOpenAI, OpenAIEmbeddings
-from langchain_text_splitters import RecursiveCharacterTextSplitter
-from langchain.tools.retriever import create_retriever_tool
-from langchain.agents import AgentExecutor, create_tool_calling_agent
-from langchain.tools import BaseTool, StructuredTool, tool
-import chainlit as cl
-import chainlit.data as cl_data
-from chainlit.data.utils import queue_until_user_message
-from chainlit.element import Element, ElementDict
-from chainlit.socket import persist_user_session
-from chainlit.step import StepDict
-from chainlit.types import (
-    Feedback,
-    PageInfo,
-    PaginatedResponse,
-    Pagination,
-    ThreadDict,
-    ThreadFilter,
-)
-from langgraph.graph import StateGraph, START, END, MessagesState
-from langgraph.prebuilt import ToolNode
-from langgraph.graph.state import CompiledStateGraph
-
-loader = WebBaseLoader("https://docs.langwatch.ai")
-docs = loader.load()
-documents = RecursiveCharacterTextSplitter(
-    chunk_size=1000, chunk_overlap=200
-).split_documents(docs)
-vector = FAISS.from_documents(documents, OpenAIEmbeddings())
-retriever = vector.as_retriever()
-
-
-@cl.on_chat_start
-async def on_chat_start():
-    retriever_tool = create_retriever_tool(
-        retriever,
-        "langwatch_search",
-        "Search for information about LangWatch. For any questions about LangWatch, use this tool if you didn't already",
-    )
-
-    tools = [retriever_tool]
-    model = ChatOpenAI(model="gpt-5", streaming=True)
-
-    # Create LangGraph workflow
-    def should_continue(state: MessagesState) -> Literal["tools", END]:
-        messages = state['messages']
-        last_message = messages[-1]
-        if last_message.tool_calls:
-            return "tools"
-        return END
-
-    def call_model(state: MessagesState):
-        messages = state['messages']
-        response = model.invoke(messages)
-        return {"messages": [response]}
-
-    workflow = StateGraph(MessagesState)
-    workflow.add_node("agent", call_model)
-    workflow.add_node("tools", ToolNode(tools))
-    workflow.add_edge(START, "agent")
-    workflow.add_conditional_edges("agent", should_continue)
-    workflow.add_edge("tools", "agent")
-
-    app = workflow.compile()
-    cl.user_session.set("agent", app)
-
-
-@cl.on_message
-async def main(message: cl.Message):
-    agent: CompiledStateGraph = cl.user_session.get("agent")  # type: ignore
-
-    msg = cl.Message(content="")
-
-    async for chunk in agent.astream(
-        {"messages": [HumanMessage(content=message.content)]},
-        config=RunnableConfig(
-            callbacks=[
-                cl.LangchainCallbackHandler(),
-            ]
-        ),
-    ):
-        if "agent" in chunk:
-            await msg.stream_token(chunk["agent"]["messages"][-1].content)
-
-    await msg.send()

package/tests/fixtures/litellm/litellm_bot_expected.py

@@ -1,40 +0,0 @@
-from typing import cast
-from dotenv import load_dotenv
-
-load_dotenv()
-
-import chainlit as cl
-import litellm
-from litellm import CustomStreamWrapper
-from litellm.types.utils import StreamingChoices
-
-import langwatch
-
-
-@cl.on_message
-@langwatch.trace()
-async def main(message: cl.Message):
-    langwatch.get_current_trace().autotrack_litellm_calls(litellm)
-
-    msg = cl.Message(
-        content="",
-    )
-
-    response = litellm.completion(
-        model="cerebras/gpt-oss-120b",
-        messages=[
-            {
-                "role": "system",
-                "content": "You are a helpful assistant that only reply in short tweet-like responses, using lots of emojis.",
-            },
-            {"role": "user", "content": message.content},
-        ],
-        stream=True,
-        stream_options={"include_usage": True},
-    )
-
-    for part in cast(CustomStreamWrapper, response):
-        if token := cast(StreamingChoices, part.choices[0]).delta.content or "":
-            await msg.stream_token(token)
-
-    await msg.update()