Merge branch 'main' into feat/sso-oidc

Author: jp-agenta

api/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "api"
-version = "0.74.0"
+version = "0.76.0"
 description = "Agenta API"
 authors = [
     { name = "Mahmoud Mabrouk", email = "[email protected]" },

docs/docs/evaluation/configure-evaluators/07-custom-evaluator.mdx

@@ -2,11 +2,7 @@
 title: "Custom Code Evaluator"
 ---
 
-Sometimes, the default evaluators in **Agenta** may not be sufficient for your specific use case. In such cases, you can create a custom evaluator to suit your specific needs. Custom evaluators are written in Python.
-
-:::info
-For the moment, there are limitation on the code that can be written in the custom evaluator. Our backend uses `RestrictedPython` to execute the code which limits the libraries that can be used.
-:::
+Sometimes, the default evaluators in **Agenta** may not be sufficient for your specific use case. In such cases, you can create a custom evaluator to suit your specific needs. Custom evaluators are written in Python, JavaScript, or TypeScript.
 
 ## Evaluation code
 

docs/docs/observability/integrations/02-langchain.mdx

@@ -19,7 +19,7 @@ This guide shows you how to instrument LangChain applications using Agenta's obs
 Install the required packages:
 
 ```bash
-pip install -U agenta openai opentelemetry-instrumentation-langchain langchain langchain_community
+pip install -U agenta openai opentelemetry-instrumentation-langchain langchain langchain-openai
 ```
 
 ## Configure Environment Variables
@@ -48,15 +48,17 @@ os.environ["AGENTA_HOST"] = "http://localhost"
 
 ## Code Example
 
+This example uses [LangChain Expression Language (LCEL)](https://python.langchain.com/docs/concepts/lcel/) to build a multi-step workflow that generates a joke and then translates it.
+
 ```python
 # highlight-next-line
 import agenta as ag
 # highlight-next-line
 from opentelemetry.instrumentation.langchain import LangchainInstrumentor
-from langchain.schema import SystemMessage, HumanMessage
-from langchain.prompts import ChatPromptTemplate, HumanMessagePromptTemplate
-from langchain_community.chat_models import ChatOpenAI
-from langchain.chains import LLMChain, SequentialChain, TransformChain
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.runnables import RunnablePassthrough, RunnableLambda
+from langchain_openai import ChatOpenAI
 
 # highlight-next-line
 ag.init()
@@ -66,43 +68,39 @@ LangchainInstrumentor().instrument()
 
 def langchain_app():
     # Initialize the chat model
-    chat = ChatOpenAI(temperature=0)
-
-    # Define a transformation chain to create the prompt
-    transform = TransformChain(
-        input_variables=["subject"],
-        output_variables=["prompt"],
-        transform=lambda inputs: {"prompt": f"Tell me a joke about {inputs['subject']}."},
-    )
-
-    # Define the first LLM chain to generate a joke
-    first_prompt_messages = [
-        SystemMessage(content="You are a funny sarcastic nerd."),
-        HumanMessage(content="{prompt}"),
-    ]
-    first_prompt_template = ChatPromptTemplate.from_messages(first_prompt_messages)
-    first_chain = LLMChain(llm=chat, prompt=first_prompt_template, output_key="joke")
-
-    # Define the second LLM chain to translate the joke
-    second_prompt_messages = [
-        SystemMessage(content="You are an Elf."),
-        HumanMessagePromptTemplate.from_template(
-            "Translate the joke below into Sindarin language:\n{joke}"
-        ),
-    ]
-    second_prompt_template = ChatPromptTemplate.from_messages(second_prompt_messages)
-    second_chain = LLMChain(llm=chat, prompt=second_prompt_template)
-
-    # Chain everything together in a sequential workflow
-    workflow = SequentialChain(
-        chains=[transform, first_chain, second_chain],
-        input_variables=["subject"],
+    llm = ChatOpenAI(temperature=0)
+
+    # Create prompt for joke generation
+    joke_prompt = ChatPromptTemplate.from_messages([
+        ("system", "You are a funny sarcastic nerd."),
+        ("human", "Tell me a joke about {subject}."),
+    ])
+
+    # Create prompt for translation
+    translate_prompt = ChatPromptTemplate.from_messages([
+        ("system", "You are an Elf."),
+        ("human", "Translate the joke below into Sindarin language:\n{joke}"),
+    ])
+
+    # Build the chain using LCEL (LangChain Expression Language)
+    # First chain: generate a joke
+    joke_chain = joke_prompt | llm | StrOutputParser()
+
+    # Second chain: translate the joke
+    translate_chain = translate_prompt | llm | StrOutputParser()
+
+    # Combine the chains: generate joke, then translate it
+    full_chain = (
+        {"subject": RunnablePassthrough()}
+        | RunnableLambda(lambda x: {"joke": joke_chain.invoke(x["subject"])})
+        | translate_chain
     )
 
     # Execute the workflow and print the result
-    result = workflow({"subject": "OpenTelemetry"})
+    result = full_chain.invoke("OpenTelemetry")
     print(result)
 
+
 # Run the LangChain application
 langchain_app()
 ```
@@ -111,6 +109,7 @@ langchain_app()
 
 - **Initialize Agenta**: `ag.init()` sets up the Agenta SDK.
 - **Instrument LangChain**: `LangchainInstrumentor().instrument()` instruments LangChain for tracing. This must be called **before** running your application to ensure all components are traced.
+- **LCEL Chains**: The pipe operator (`|`) chains components together. Each step's output becomes the next step's input, making it easy to compose complex workflows.
 
 ## Using Workflows
 

docs/docs/tutorials/cookbooks/02-observability_langchain.mdx

@@ -73,9 +73,7 @@ This Langchain RAG application:
 ```python
 from langchain_openai import ChatOpenAI
 
-
 import bs4
-from langchain import hub
 from langchain_chroma import Chroma
 from langchain_community.document_loaders import WebBaseLoader
 from langchain_core.output_parsers import StrOutputParser

examples/jupyter/observability/observability_langchain.ipynb

@@ -135,78 +135,8 @@
    "cell_type": "code",
    "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'To save a new version of a prompt in Agenta, you need to create a variant, which acts like a branch in git for versioning. After making your changes, commit them to the variant. Finally, you can deploy the specific version of your variant to the desired environment.'"
-      ]
-     },
-     "execution_count": 16,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from langchain_openai import ChatOpenAI\n",
-    "\n",
-    "\n",
-    "import bs4\n",
-    "from langchain import hub\n",
-    "from langchain_chroma import Chroma\n",
-    "from langchain_community.document_loaders import WebBaseLoader\n",
-    "from langchain_core.output_parsers import StrOutputParser\n",
-    "from langchain_core.runnables import RunnablePassthrough\n",
-    "from langchain_openai import OpenAIEmbeddings\n",
-    "from langchain_text_splitters import RecursiveCharacterTextSplitter\n",
-    "from langchain_core.prompts import ChatPromptTemplate\n",
-    "\n",
-    "prompt = \"\"\"\n",
-    "You are an assistant for question-answering tasks.\n",
-    "Use the following pieces of retrieved context to answer the question.\n",
-    "If you don't know the answer, just say that you don't know.\n",
-    "Use three sentences maximum and keep the answer concise and to the point.\n",
-    "\n",
-    "Question: {question} \n",
-    "\n",
-    "Context: {context} \n",
-    "\n",
-    "Answer:\n",
-    "\"\"\"\n",
-    "\n",
-    "prompt_template = ChatPromptTemplate(\n",
-    "    [\n",
-    "        (\"human\", prompt),\n",
-    "    ]\n",
-    ")\n",
-    "\n",
-    "llm = ChatOpenAI(model=\"gpt-4o-mini\")\n",
-    "\n",
-    "loader = WebBaseLoader(\n",
-    "    web_paths=(\n",
-    "        \"https://agenta.ai/docs/prompt-engineering/managing-prompts-programatically/create-and-commit\",\n",
-    "    ),\n",
-    "    bs_kwargs=dict(parse_only=bs4.SoupStrainer(\"article\")),  # Only parse the core\n",
-    ")\n",
-    "docs = loader.load()\n",
-    "\n",
-    "text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)\n",
-    "splits = text_splitter.split_documents(docs)\n",
-    "vectorstore = Chroma.from_documents(documents=splits, embedding=OpenAIEmbeddings())\n",
-    "\n",
-    "# Retrieve and generate using the relevant snippets of the blog.\n",
-    "retriever = vectorstore.as_retriever()\n",
-    "\n",
-    "\n",
-    "rag_chain = (\n",
-    "    {\"context\": retriever, \"question\": RunnablePassthrough()}\n",
-    "    | prompt_template\n",
-    "    | llm\n",
-    "    | StrOutputParser()\n",
-    ")\n",
-    "\n",
-    "rag_chain.invoke(\"How can I save a new version of a prompt in Agenta?\")"
-   ]
+   "outputs": [],
+   "source": "from langchain_openai import ChatOpenAI\n\nimport bs4\nfrom langchain_chroma import Chroma\nfrom langchain_community.document_loaders import WebBaseLoader\nfrom langchain_core.output_parsers import StrOutputParser\nfrom langchain_core.runnables import RunnablePassthrough\nfrom langchain_openai import OpenAIEmbeddings\nfrom langchain_text_splitters import RecursiveCharacterTextSplitter\nfrom langchain_core.prompts import ChatPromptTemplate\n\nprompt = \"\"\"\nYou are an assistant for question-answering tasks.\nUse the following pieces of retrieved context to answer the question.\nIf you don't know the answer, just say that you don't know.\nUse three sentences maximum and keep the answer concise and to the point.\n\nQuestion: {question} \n\nContext: {context} \n\nAnswer:\n\"\"\"\n\nprompt_template = ChatPromptTemplate(\n    [\n        (\"human\", prompt),\n    ]\n)\n\nllm = ChatOpenAI(model=\"gpt-4o-mini\")\n\nloader = WebBaseLoader(\n    web_paths=(\n        \"https://agenta.ai/docs/prompt-engineering/managing-prompts-programatically/create-and-commit\",\n    ),\n    bs_kwargs=dict(parse_only=bs4.SoupStrainer(\"article\")),  # Only parse the core\n)\ndocs = loader.load()\n\ntext_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)\nsplits = text_splitter.split_documents(docs)\nvectorstore = Chroma.from_documents(documents=splits, embedding=OpenAIEmbeddings())\n\n# Retrieve and generate using the relevant snippets of the blog.\nretriever = vectorstore.as_retriever()\n\n\nrag_chain = (\n    {\"context\": retriever, \"question\": RunnablePassthrough()}\n    | prompt_template\n    | llm\n    | StrOutputParser()\n)\n\nrag_chain.invoke(\"How can I save a new version of a prompt in Agenta?\")"
   }
  ],
  "metadata": {
@@ -230,4 +160,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 2
-}
+}

sdk/agenta/sdk/workflows/runners/registry.py

@@ -19,7 +19,7 @@ def get_runner() -> CodeRunner:
     Registry to get the appropriate code runner based on environment configuration.
 
     Uses AGENTA_SERVICES_SANDBOX_RUNNER environment variable:
-    - "local" (default): Uses RestrictedPython for local execution
+    - "local" (default): Uses current container for local execution
     - "daytona": Uses Daytona remote sandbox
 
     Returns:

sdk/agenta/sdk/workflows/templates.py

@@ -48,7 +48,7 @@
 // Ensure result is a number
 result = Number(result);
 if (!Number.isFinite(result)) {{
-    result = 0.0;
+    result = null;
 }}
 
 // Print result for capture
@@ -71,7 +71,7 @@
 // Ensure result is a number
 result = Number(result);
 if (!Number.isFinite(result)) {{
-    result = 0.0;
+    result = null;
 }}
 
 // Print result for capture

sdk/poetry.lock

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "agenta"
-version = "0.74.0"
+version = "0.76.0"
 description = "The SDK for agenta is an open-source LLMOps platform."
 readme = "README.md"
 authors = [

sdk/pyproject.toml

@@ -1,6 +1,6 @@
 {
     "name": "@agenta/ee",
-    "version": "0.74.0",
+    "version": "0.76.0",
     "private": true,
     "engines": {
         "node": ">=18"