@langwatch/mcp-server 0.7.0 → 0.9.0

package/tests/fixtures/litellm/litellm_bot_input.py

@@ -1,35 +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
-
-
-@cl.on_message
-async def main(message: cl.Message):
-    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()

package/tests/fixtures/openai/openai_bot_expected.py

@@ -1,43 +0,0 @@
-from dotenv import load_dotenv
-
-load_dotenv()
-
-import chainlit as cl
-from openai import OpenAI
-import langwatch
-
-client = OpenAI()
-
-
-@cl.on_message
-@langwatch.trace()
-async def main(message: cl.Message):
-    langwatch.get_current_trace().autotrack_openai_calls(client)
-    langwatch.get_current_trace().update(
-        metadata={"labels": ["openai"]},
-    )
-
-    msg = cl.Message(
-        content="",
-    )
-
-    completion = client.chat.completions.create(
-        model="gpt-5",
-        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 completion:
-        if len(part.choices) == 0:
-            continue
-        if token := part.choices[0].delta.content or "":
-            await msg.stream_token(token)
-
-    await msg.update()

package/tests/fixtures/openai/openai_bot_function_call_expected.py

@@ -1,91 +0,0 @@
-from dotenv import load_dotenv
-
-load_dotenv()
-
-import chainlit as cl
-from openai import OpenAI
-
-client = OpenAI()
-
-import langwatch
-
-import json
-
-
-@langwatch.span(type="tool")
-def get_weather(city: str):
-    return "27°C and sunny"
-
-
-@cl.on_message
-@langwatch.trace()
-async def main(message: cl.Message):
-    langwatch.get_current_trace().autotrack_openai_calls(client)
-    langwatch.get_current_trace().update(
-        metadata={"labels": ["openai", "tools"]},
-    )
-
-    msg = cl.Message(
-        content="",
-    )
-
-    completion = client.chat.completions.create(
-        model="gpt-5",
-        messages=[
-            {
-                "role": "system",
-                "content": "You are a helpful assistant that calls tools that gives weather predictions.",
-            },
-            {"role": "user", "content": message.content},
-        ],
-        tools=[
-            {
-                "type": "function",
-                "function": {
-                    "name": "get_weather",
-                    "description": "Get the weather for a city.",
-                    "parameters": {
-                        "type": "object",
-                        "properties": {
-                            "city": {
-                                "type": "string",
-                                "description": "The city to get the weather for.",
-                            },
-                        },
-                        "required": ["city"],
-                    },
-                },
-            }
-        ],
-        tool_choice={
-            "type": "function",
-            "function": {
-                "name": "get_weather",
-            },
-        },
-    )
-
-    tool_message = completion.choices[0].message.tool_calls[0]  # type: ignore
-    weather_call = json.loads(tool_message.function.arguments)  # type: ignore
-
-    weather = get_weather(weather_call["city"])
-
-    completion = client.chat.completions.create(
-        model="gpt-5",
-        messages=[
-            {
-                "role": "system",
-                "content": "You are a helpful assistant that gives weather predictions based on the tool results.",
-            },
-            {"role": "user", "content": message.content},
-            completion.choices[0].message,
-            {"tool_call_id": tool_message.id, "role": "tool", "name": tool_message.function.name, "content": weather},  # type: ignore
-        ],
-        stream=True,
-    )
-
-    for part in completion:
-        if token := part.choices[0].delta.content or "":
-            await msg.stream_token(token)
-
-    await msg.update()

package/tests/fixtures/openai/openai_bot_function_call_input.py

@@ -1,82 +0,0 @@
-from dotenv import load_dotenv
-
-load_dotenv()
-
-import chainlit as cl
-from openai import OpenAI
-
-client = OpenAI()
-
-import json
-
-
-def get_weather(city: str):
-    return "27°C and sunny"
-
-
-@cl.on_message
-async def main(message: cl.Message):
-    msg = cl.Message(
-        content="",
-    )
-
-    completion = client.chat.completions.create(
-        model="gpt-5",
-        messages=[
-            {
-                "role": "system",
-                "content": "You are a helpful assistant that calls tools that gives weather predictions.",
-            },
-            {"role": "user", "content": message.content},
-        ],
-        tools=[
-            {
-                "type": "function",
-                "function": {
-                    "name": "get_weather",
-                    "description": "Get the weather for a city.",
-                    "parameters": {
-                        "type": "object",
-                        "properties": {
-                            "city": {
-                                "type": "string",
-                                "description": "The city to get the weather for.",
-                            },
-                        },
-                        "required": ["city"],
-                    },
-                },
-            }
-        ],
-        tool_choice={
-            "type": "function",
-            "function": {
-                "name": "get_weather",
-            },
-        },
-    )
-
-    tool_message = completion.choices[0].message.tool_calls[0]  # type: ignore
-    weather_call = json.loads(tool_message.function.arguments)  # type: ignore
-
-    weather = get_weather(weather_call["city"])
-
-    completion = client.chat.completions.create(
-        model="gpt-5",
-        messages=[
-            {
-                "role": "system",
-                "content": "You are a helpful assistant that gives weather predictions based on the tool results.",
-            },
-            {"role": "user", "content": message.content},
-            completion.choices[0].message,
-            {"tool_call_id": tool_message.id, "role": "tool", "name": tool_message.function.name, "content": weather},  # type: ignore
-        ],
-        stream=True,
-    )
-
-    for part in completion:
-        if token := part.choices[0].delta.content or "":
-            await msg.stream_token(token)
-
-    await msg.update()

package/tests/fixtures/openai/openai_bot_input.py

@@ -1,36 +0,0 @@
-from dotenv import load_dotenv
-
-load_dotenv()
-
-import chainlit as cl
-from openai import OpenAI
-
-client = OpenAI()
-
-
-@cl.on_message
-async def main(message: cl.Message):
-    msg = cl.Message(
-        content="",
-    )
-
-    completion = client.chat.completions.create(
-        model="gpt-5",
-        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 completion:
-        if len(part.choices) == 0:
-            continue
-        if token := part.choices[0].delta.content or "":
-            await msg.stream_token(token)
-
-    await msg.update()

package/tests/fixtures/openai/openai_bot_rag_expected.py

@@ -1,73 +0,0 @@
-from dotenv import load_dotenv
-
-from langwatch.types import RAGChunk
-
-load_dotenv()
-
-import chainlit as cl
-from openai import OpenAI
-
-client = OpenAI()
-
-import langwatch.openai
-
-
-@langwatch.span(type="rag")
-def rag_retrieval(query: str):
-    # the documents you retrieved from your vector database
-    search_results = [
-        {
-            "id": "doc-1",
-            "content": "France is a country in Europe.",
-        },
-        {
-            "id": "doc-2",
-            "content": "Paris is the capital of France.",
-        },
-    ]
-
-    # capture then on the span contexts with RAGChunk before returning
-    langwatch.get_current_span().update(
-        contexts=[
-            RAGChunk(
-                document_id=document["id"],
-                content=document["content"],
-            )
-            for document in search_results
-        ]
-    )
-
-    return search_results
-
-
-@cl.on_message
-@langwatch.trace()
-async def main(message: cl.Message):
-    langwatch.get_current_trace().autotrack_openai_calls(client)
-    langwatch.get_current_trace().update(
-        metadata={"labels": ["openai", "rag"]},
-    )
-
-    msg = cl.Message(
-        content="",
-    )
-
-    contexts = rag_retrieval(message.content)
-
-    completion = client.chat.completions.create(
-        model="gpt-5",
-        messages=[
-            {
-                "role": "system",
-                "content": f"You are a helpful assistant that only reply in short tweet-like responses, using lots of emojis. {contexts}",
-            },
-            {"role": "user", "content": message.content},
-        ],
-        stream=True,
-    )
-
-    for part in completion:
-        if token := part.choices[0].delta.content or "":
-            await msg.stream_token(token)
-
-    await msg.update()

package/tests/fixtures/openai/openai_bot_rag_input.py

@@ -1,51 +0,0 @@
-from dotenv import load_dotenv
-
-load_dotenv()
-
-import chainlit as cl
-from openai import OpenAI
-
-client = OpenAI()
-
-
-def rag_retrieval(query: str):
-    # the documents you retrieved from your vector database
-    search_results = [
-        {
-            "id": "doc-1",
-            "content": "France is a country in Europe.",
-        },
-        {
-            "id": "doc-2",
-            "content": "Paris is the capital of France.",
-        },
-    ]
-
-    return search_results
-
-
-@cl.on_message
-async def main(message: cl.Message):
-    msg = cl.Message(
-        content="",
-    )
-
-    contexts = rag_retrieval(message.content)
-
-    completion = client.chat.completions.create(
-        model="gpt-5",
-        messages=[
-            {
-                "role": "system",
-                "content": f"You are a helpful assistant that only reply in short tweet-like responses, using lots of emojis. {contexts}",
-            },
-            {"role": "user", "content": message.content},
-        ],
-        stream=True,
-    )
-
-    for part in completion:
-        if token := part.choices[0].delta.content or "":
-            await msg.stream_token(token)
-
-    await msg.update()

package/tests/fixtures/opentelemetry/openinference_dspy_bot_expected.py

@@ -1,63 +0,0 @@
-import os
-import dspy
-from dotenv import load_dotenv
-
-import langwatch
-
-load_dotenv()
-
-import chainlit as cl
-
-from openinference.instrumentation.dspy import DSPyInstrumentor
-
-langwatch.setup(
-    instrumentors=[DSPyInstrumentor()],
-)
-
-llm = dspy.OpenAI(
-    model="gpt-5",
-    max_tokens=2048,
-    temperature=0,
-    api_key=os.environ["OPENAI_API_KEY"],
-)
-
-colbertv2_wiki17_abstracts = dspy.ColBERTv2(
-    url="http://20.102.90.50:2017/wiki17_abstracts"
-)
-
-dspy.settings.configure(lm=llm, rm=colbertv2_wiki17_abstracts)
-
-
-class GenerateAnswer(dspy.Signature):
-    """Answer questions with short factoid answers."""
-
-    context = dspy.InputField(desc="may contain relevant facts")
-    question = dspy.InputField()
-    answer = dspy.OutputField(desc="often between 1 and 5 words")
-
-
-class RAG(dspy.Module):
-    def __init__(self, num_passages=3):
-        super().__init__()
-
-        self.retrieve = dspy.Retrieve(k=num_passages)
-        self.generate_answer = dspy.ChainOfThought(GenerateAnswer)
-
-    def forward(self, question):
-        context = self.retrieve(question).passages  # type: ignore
-        prediction = self.generate_answer(question=question, context=context)
-        return dspy.Prediction(answer=prediction.answer)
-
-
-@cl.on_message
-async def main(message: cl.Message):
-    msg = cl.Message(
-        content="",
-    )
-
-    program = RAG()
-    program = program.reset_copy()
-    prediction = program(question=message.content)
-
-    await msg.stream_token(prediction.answer)
-    await msg.update()

package/tests/fixtures/opentelemetry/openinference_dspy_bot_input.py

@@ -1,58 +0,0 @@
-# This example uses the OpenTelemetry instrumentation for DSPy from OpenInference
-
-import os
-from dotenv import load_dotenv
-
-load_dotenv()
-
-import chainlit as cl
-
-import dspy
-from openinference.instrumentation.dspy import DSPyInstrumentor
-
-# Manual instrumentation setup would go here
-DSPyInstrumentor().instrument()
-
-lm = dspy.LM("openai/gpt-5", api_key=os.environ["OPENAI_API_KEY"], temperature=1)
-
-colbertv2_wiki17_abstracts = dspy.ColBERTv2(
-    url="http://20.102.90.50:2017/wiki17_abstracts"
-)
-
-dspy.settings.configure(lm=lm, rm=colbertv2_wiki17_abstracts)
-
-
-class GenerateAnswer(dspy.Signature):
-    """Answer questions with careful explanations to the user."""
-
-    context = dspy.InputField(desc="may contain relevant facts")
-    question = dspy.InputField()
-    answer = dspy.OutputField(desc="markdown formatted answer, use some emojis")
-
-
-class RAG(dspy.Module):
-    def __init__(self, num_passages=3):
-        super().__init__()
-
-        self.retrieve = dspy.Retrieve(k=num_passages)
-        self.generate_answer = dspy.ChainOfThought(GenerateAnswer)
-
-    def forward(self, question):
-        context = self.retrieve(question).passages  # type: ignore
-        prediction = self.generate_answer(question=question, context=context)
-        return dspy.Prediction(answer=prediction.answer)
-
-
-@cl.on_message
-async def main(message: cl.Message):
-    msg = cl.Message(
-        content="",
-    )
-
-    program = RAG()
-    prediction = program(question=message.content)
-
-    await msg.stream_token(prediction.answer)
-    await msg.update()
-
-    return prediction.answer

package/tests/fixtures/opentelemetry/openinference_langchain_bot_expected.py

@@ -1,53 +0,0 @@
-from dotenv import load_dotenv
-from langchain_openai import ChatOpenAI
-
-import langwatch
-
-load_dotenv()
-
-import chainlit as cl
-from langchain.prompts import ChatPromptTemplate
-from langchain.schema import StrOutputParser
-from langchain.schema.runnable import Runnable
-from langchain.schema.runnable.config import RunnableConfig
-
-from openinference.instrumentation.langchain import LangChainInstrumentor
-
-langwatch.setup(
-    instrumentors=[LangChainInstrumentor()],
-)
-
-
-@cl.on_chat_start
-async def on_chat_start():
-    model = ChatOpenAI(streaming=True)
-    prompt = ChatPromptTemplate.from_messages(
-        [
-            (
-                "system",
-                "You are a helpful assistant that only reply in short tweet-like responses, using lots of emojis.",
-            ),
-            ("human", "{question}"),
-        ]
-    )
-    runnable = prompt | model | StrOutputParser()
-    cl.user_session.set("runnable", runnable)
-
-
-@cl.on_message
-async def main(message: cl.Message):
-    runnable: Runnable = cl.user_session.get("runnable")  # type: ignore
-
-    msg = cl.Message(content="")
-
-    async for chunk in runnable.astream(
-        {"question": message.content},
-        config=RunnableConfig(
-            callbacks=[
-                cl.LangchainCallbackHandler(),
-            ]
-        ),
-    ):
-        await msg.stream_token(chunk)
-
-    await msg.send()

package/tests/fixtures/opentelemetry/openinference_langchain_bot_input.py

@@ -1,52 +0,0 @@
-# This example uses the OpenTelemetry instrumentation for LangChain from OpenInference
-
-from dotenv import load_dotenv
-from langchain_openai import ChatOpenAI
-
-load_dotenv()
-
-import chainlit as cl
-from langchain.prompts import ChatPromptTemplate
-from langchain.schema import StrOutputParser
-from langchain.schema.runnable import Runnable
-from langchain.schema.runnable.config import RunnableConfig
-
-from openinference.instrumentation.langchain import LangChainInstrumentor
-
-# Manual instrumentation setup would go here
-LangChainInstrumentor().instrument()
-
-
-@cl.on_chat_start
-async def on_chat_start():
-    model = ChatOpenAI(streaming=True)
-    prompt = ChatPromptTemplate.from_messages(
-        [
-            (
-                "system",
-                "You are a helpful assistant that only reply in short tweet-like responses, using lots of emojis.",
-            ),
-            ("human", "{question}"),
-        ]
-    )
-    runnable = prompt | model | StrOutputParser()
-    cl.user_session.set("runnable", runnable)
-
-
-@cl.on_message
-async def main(message: cl.Message):
-    runnable: Runnable = cl.user_session.get("runnable")  # type: ignore
-
-    msg = cl.Message(content="")
-
-    async for chunk in runnable.astream(
-        {"question": message.content},
-        config=RunnableConfig(
-            callbacks=[
-                cl.LangchainCallbackHandler(),
-            ]
-        ),
-    ):
-        await msg.stream_token(chunk)
-
-    await msg.send()

package/tests/fixtures/opentelemetry/openinference_openai_bot_expected.py

@@ -1,49 +0,0 @@
-# This example uses the OpenTelemetry instrumentation for OpenAI from OpenInference: https://pypi.org/project/openinference-instrumentation-openai/
-
-from dotenv import load_dotenv
-
-import langwatch
-
-load_dotenv()
-
-import chainlit as cl
-
-from openinference.instrumentation.openai import OpenAIInstrumentor
-from openinference.instrumentation import using_attributes
-from openai import OpenAI
-
-client = OpenAI()
-langwatch.setup(
-    instrumentors=[OpenAIInstrumentor()],
-)
-
-
-@cl.on_message
-async def main(message: cl.Message):
-    msg = cl.Message(
-        content="",
-    )
-
-    with using_attributes(
-        session_id="my-test-session",
-        user_id="my-test-user",
-        tags=["tag-1", "tag-2"],
-        metadata={"foo": "bar"},
-    ):
-        completion = client.chat.completions.create(
-            model="gpt-5",
-            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,
-        )
-
-    for part in completion:
-        if token := part.choices[0].delta.content or "":
-            await msg.stream_token(token)
-
-    await msg.update()