Merge branch 'main' into telemetry-update

Author: CalebCourier

docs/faq.md

@@ -1,5 +1,21 @@
 # Frequently Asked Questions
 
+## I get an "Unauthorized" error when installing validators from the Guardrails Hub. What should I do?
+
+If you see an "Unauthorized" error when installing validators from the Guardrails hub, it means that the API key you are using is not authorized to access the Guardrails hub. It may be unset or expired. 
+
+To fix this, first generate a new API key from the [Guardrails Hub](https://hub.guardrailsai.com/keys). Then, configure the Guardrails CLI with the new API key.
+
+```bash
+guardrails configure
+```
+
+There is also a headless option to configure the CLI with the token.
+
+```bash
+guardrails configure --token <your_token>
+```
+
 ## I'm seeing a PromptCallableException when invoking my Guard. What should I do?
 
 If you see an exception that looks like this

docs/getting_started/guardrails_server.md

@@ -13,6 +13,13 @@ This document will overview a few of the key features of the Guardrails Server,
 
 # Walkthrough
 
+## 0. Configure Guardrails
+First, get a free auth key from [Guardrails Hub](https://hub.guardrailsai.com/keys). Then, configure the Guardrails CLI with the auth key.
+
+```bash
+guardrails configure
+```
+
 ## 1. Install the Guardrails Server
 This is done by simply installing the `guardrails-ai` package. See the [installation guide](./quickstart.md) for more information.
 

docs/getting_started/quickstart.md

@@ -17,6 +17,8 @@ pip install guardrails-ai
 ```
 
 ### Configure the Guardrails CLI (required)
+
+First, get a free auth key from [Guardrails Hub](https://hub.guardrailsai.com/keys). Then, configure the Guardrails CLI with the auth key.
 
 ```bash
 guardrails configure

docs/how_to_guides/using_llms.md

@@ -289,3 +289,49 @@ for chunk in stream_chunk_generator
 ## Other LLMs
 
 See LiteLLM’s documentation [here](https://docs.litellm.ai/docs/providers) for details on many other llms.
+
+## Custom LLM Wrappers
+In case you're using an LLM that isn't natively supported by Guardrails and you don't want to use LiteLLM, you can build a custom LLM API wrapper. In order to use a custom LLM, create a function that accepts a positional argument for the prompt as a string and any other arguments that you want to pass to the LLM API as keyword args. The function should return the output of the LLM API as a string.
+
+```python
+from guardrails import Guard
+from guardrails.hub import ProfanityFree
+
+# Create a Guard class
+guard = Guard().use(ProfanityFree())
+
+# Function that takes the prompt as a string and returns the LLM output as string
+def my_llm_api(
+    prompt: Optional[str] = None,
+    *,
+    instructions: Optional[str] = None,
+    msg_history: Optional[list[dict]] = None,
+    **kwargs
+) -> str:
+    """Custom LLM API wrapper.
+
+    At least one of prompt, instruction or msg_history should be provided.
+
+    Args:
+        prompt (str): The prompt to be passed to the LLM API
+        instruction (str): The instruction to be passed to the LLM API
+        msg_history (list[dict]): The message history to be passed to the LLM API
+        **kwargs: Any additional arguments to be passed to the LLM API
+
+    Returns:
+        str: The output of the LLM API
+    """
+
+    # Call your LLM API here
+    # What you pass to the llm will depend on what arguments it accepts.
+    llm_output = some_llm(prompt, instructions, msg_history, **kwargs)
+
+    return llm_output
+
+# Wrap your LLM API call
+validated_response = guard(
+    my_llm_api,
+    prompt="Can you generate a list of 10 things that are not food?",
+    **kwargs,
+)
+```

guardrails/applications/text2sql.py

@@ -1,14 +1,14 @@
 import asyncio
 import json
 import os
+import openai
 from string import Template
 from typing import Callable, Dict, Optional, Type, cast
 
 from guardrails.classes import ValidationOutcome
 from guardrails.document_store import DocumentStoreBase, EphemeralDocumentStore
 from guardrails.embedding import EmbeddingBase, OpenAIEmbedding
 from guardrails.guard import Guard
-from guardrails.utils.openai_utils import get_static_openai_create_func
 from guardrails.utils.sql_utils import create_sql_driver
 from guardrails.vectordb import Faiss, VectorDBBase
 
@@ -89,7 +89,7 @@ def __init__(
             reask_prompt: Prompt to use for reasking. Defaults to REASK_PROMPT.
         """
         if llm_api is None:
-            llm_api = get_static_openai_create_func()
+            llm_api = openai.completions.create
 
         self.example_formatter = example_formatter
         self.llm_api = llm_api

guardrails/cli/configure.py

@@ -12,7 +12,7 @@
 from guardrails.cli.hub.console import console
 from guardrails.cli.server.hub_client import AuthenticationError, get_auth
 from guardrails.cli.telemetry import trace_if_enabled
-
+from guardrails.cli.version import version_warnings_if_applicable
 
 DEFAULT_TOKEN = ""
 DEFAULT_ENABLE_METRICS = True
@@ -78,6 +78,7 @@ def configure(
         help="Clear the existing token from the configuration file.",
     ),
 ):
+    version_warnings_if_applicable(console)
     if settings.rc.exists():
         trace_if_enabled("configure")
     existing_token = _get_default_token()

guardrails/cli/hub/install.py

@@ -6,6 +6,8 @@
 from guardrails.cli.hub.hub import hub_command
 from guardrails.cli.logger import logger
 from guardrails.hub_telemetry.hub_tracing import trace
+from guardrails.cli.hub.console import console
+from guardrails.cli.version import version_warnings_if_applicable
 
 
 @trace(name="guardrails-cli/hub/install", is_parent=True)
@@ -40,6 +42,8 @@ def confirm():
                 " local models for local inference?",
             )
 
+        version_warnings_if_applicable(console)
+
         install_multiple(
             package_uris,
             install_local_models=local_models,

guardrails/cli/start.py

@@ -5,6 +5,8 @@
 from guardrails.cli.hub.utils import pip_process
 from guardrails.cli.logger import logger
 from guardrails.cli.telemetry import trace_if_enabled
+from guardrails.cli.version import version_warnings_if_applicable
+from guardrails.cli.hub.console import console
 
 
 def api_is_installed() -> bool:
@@ -39,5 +41,6 @@ def start(
     from guardrails_api.cli.start import start  # type: ignore
 
     logger.info("Starting Guardrails server")
+    version_warnings_if_applicable(console)
     trace_if_enabled("start")
     start(env, config, port)

guardrails/cli/version.py

@@ -0,0 +1,31 @@
+import contextlib
+import requests
+import semver
+from importlib.metadata import version
+from rich.console import Console
+
+
+GUARDRAILS_PACKAGE_NAME = "guardrails-ai"
+
+
+def get_guardrails_version():
+    return version(GUARDRAILS_PACKAGE_NAME)
+
+
+def version_warnings_if_applicable(console: Console):
+    current_version = get_guardrails_version()
+
+    with contextlib.suppress(Exception):
+        res = requests.get(f"https://pypi.org/pypi/{GUARDRAILS_PACKAGE_NAME}/json")
+        version_info = res.json()
+        info = version_info.get("info", {})
+        latest_version = info.get("version")
+
+        is_update_available = semver.compare(latest_version, current_version) > 0
+
+        if is_update_available:
+            console.print(
+                "[yellow]There is a newer version of Guardrails "
+                f"available {latest_version}. Your current version "
+                f"is {current_version}[/yellow]!"
+            )

guardrails/formatters/json_formatter.py

@@ -1,5 +1,5 @@
 import json
-from typing import Optional, Union
+from typing import Dict, List, Optional, Union
 
 from guardrails.formatters.base_formatter import BaseFormatter
 from guardrails.llm_providers import (
@@ -99,32 +99,48 @@ def wrap_callable(self, llm_callable) -> ArbitraryCallable:
 
         if isinstance(llm_callable, HuggingFacePipelineCallable):
             model = llm_callable.init_kwargs["pipeline"]
-            return ArbitraryCallable(
-                lambda p: json.dumps(
+
+            def fn(
+                prompt: str,
+                *args,
+                instructions: Optional[str] = None,
+                msg_history: Optional[List[Dict[str, str]]] = None,
+                **kwargs,
+            ) -> str:
+                return json.dumps(
                     Jsonformer(
                         model=model.model,
                         tokenizer=model.tokenizer,
                         json_schema=self.output_schema,
-                        prompt=p,
+                        prompt=prompt,
                     )()
                 )
-            )
+
+            return ArbitraryCallable(fn)
         elif isinstance(llm_callable, HuggingFaceModelCallable):
             # This will not work because 'model_generate' is the .gen method.
             # model = self.api.init_kwargs["model_generate"]
             # Use the __self__ to grab the base mode for passing into JF.
             model = llm_callable.init_kwargs["model_generate"].__self__
             tokenizer = llm_callable.init_kwargs["tokenizer"]
-            return ArbitraryCallable(
-                lambda p: json.dumps(
+
+            def fn(
+                prompt: str,
+                *args,
+                instructions: Optional[str] = None,
+                msg_history: Optional[List[Dict[str, str]]] = None,
+                **kwargs,
+            ) -> str:
+                return json.dumps(
                     Jsonformer(
                         model=model,
                         tokenizer=tokenizer,
                         json_schema=self.output_schema,
-                        prompt=p,
+                        prompt=prompt,
                     )()
                 )
-            )
+
+            return ArbitraryCallable(fn)
         else:
             raise ValueError(
                 "JsonFormatter can only be used with HuggingFace*Callable."