![](\"figures/favicon/apple-touch-icon-180x180.png\"){kind=icon}
\n\nRun multiple LLM predictions against a data frame. The predictions are processed \nrow-wise over a specified column. It works using a pre-determined one-shot prompt,\nalong with the current row's content. The prompt that is use will depend of the\ntype of analysis needed. \n\nCurrently, the included prompts perform the following: \n\n- [Sentiment analysis](#sentiment)\n- [Text summarizing](#summarize)\n- [Classify text](#classify)\n- [Extract one, or several](#extract), specific pieces information from the text\n- [Translate text](#translate)\n- [Custom prompt](#custom-prompt)\n\nThis package is inspired by the SQL AI functions now offered by vendors such as\n[Databricks](https://docs.databricks.com/en/large-language-models/ai-functions.html) \nand Snowflake. `mall` uses [Ollama](https://ollama.com/) to interact with LLMs \ninstalled locally. \n\n\nFor R, that interaction takes place via the \n[`ollamar`](https://hauselin.github.io/ollama-r/) package. The functions are \ndesigned to easily work with piped commands, such as `dplyr`. \n\n```r\nreviews |>\n llm_sentiment(review)\n```\n\n\nFor Python, `mall` includes an extension to [Polars](https://pola.rs/). To\ninteract with Ollama, it uses the official [Python library](https://github.com/ollama/ollama-python).\n\n```python\nreviews.llm.sentiment(\"review\")\n```\n\n## Motivation\n\nWe want to new find ways to help data scientists use LLMs in their daily work. \nUnlike the familiar interfaces, such as chatting and code completion, this interface\nruns your text data directly against the LLM. \n\nThe LLM's flexibility, allows for it to adapt to the subject of your data, and \nprovide surprisingly accurate predictions. This saves the data scientist the\nneed to write and tune an NLP model. \n\nIn recent times, the capabilities of LLMs that can run locally in your computer \nhave increased dramatically. This means that these sort of analysis can run\nin your machine with good accuracy. Additionally, it makes it possible to take\nadvantage of LLM's at your institution, since the data will not leave the\ncorporate network. \n\n## Get started\n\n- Install `mall` from Github\n\n \n::: {.panel-tabset group=\"language\"}\n## R\n```r\npak::pak(\"edgararuiz/mall/r@python\")\n```\n\n## python\n```python\npip install \"mall @ git+https://git@github.com/edgararuiz/mall.git@python#subdirectory=python\"\n```\n:::\n \n\n### With local LLMs\n\n- [Download Ollama from the official website](https://ollama.com/download)\n\n- Install and start Ollama in your computer\n\n\n::: {.panel-tabset group=\"language\"}\n## R\n- Install Ollama in your machine. The `ollamar` package's website provides this\n[Installation guide](https://hauselin.github.io/ollama-r/#installation)\n\n- Download an LLM model. For example, I have been developing this package using\nLlama 3.2 to test. To get that model you can run: \n ```r\n ollamar::pull(\"llama3.2\")\n ```\n \n## python\n\n- Install the official Ollama library\n ```python\n pip install ollama\n ```\n\n- Download an LLM model. For example, I have been developing this package using\nLlama 3.2 to test. To get that model you can run: \n ```python\n import ollama\n ollama.pull('llama3.2')\n ```\n:::\n\n\n \n### With Databricks (R only)\n\nIf you pass a table connected to **Databricks** via `odbc`, `mall` will \nautomatically use Databricks' LLM instead of Ollama. *You won't need Ollama \ninstalled if you are using Databricks only.*\n\n`mall` will call the appropriate SQL AI function. For more information see our \n[Databricks article.](https://edgararuiz.github.io/mall/articles/databricks.html) \n\n## LLM functions\n\n### Sentiment\n\nPrimarily, `mall` provides verb-like functions that expect a data frame as \ntheir first argument. \n\nWe will start with loading a very small data set contained in `mall`. It has\n3 product reviews that we will use as the source of our examples.\n\n::: {.panel-tabset group=\"language\"}\n## R\n\n\n\n::: {.cell}\n\n```{.r .cell-code}\nlibrary(mall)\n\ndata(\"reviews\")\n\nreviews\n#> # A tibble: 3 × 1\n#> review \n#> \nshape: (3, 1)
\n```\n\n:::\n:::\n\n\n:::\n\n\n\n\n\n\n\nFor the first example, we'll asses the sentiment of each review:\n\n::: {.panel-tabset group=\"language\"}\n## R\n\n\n\n::: {.cell}\n\n```{.r .cell-code}\n\nreviews |>\n llm_sentiment(review)\n#> # A tibble: 3 × 2\n#> review .sentiment\n#> | review |
|---|
| str |
| "This has been the best TV I've… |
| "I regret buying this laptop. I… |
| "Not sure how to feel about my … |
\nshape: (3, 2)
\n```\n\n:::\n:::\n\n\n\n:::\n\nWe can also provide custom sentiment labels. Use the `options` argument to control\nthat:\n\n::: {.panel-tabset group=\"language\"}\n## R\n\n\n\n::: {.cell}\n\n```{.r .cell-code}\n\nreviews |>\n llm_sentiment(review, options = c(\"positive\", \"negative\"))\n#> # A tibble: 3 × 2\n#> review .sentiment\n#> | review | sentiment |
|---|---|
| str | str |
| "This has been the best TV I've… | "positive" |
| "I regret buying this laptop. I… | "negative" |
| "Not sure how to feel about my … | "neutral" |
\nshape: (3, 2)
\n```\n\n:::\n:::\n\n\n\n:::\n\nAs mentioned before, these functions are create to play well with the rest of \nthe analysis\n\n::: {.panel-tabset group=\"language\"}\n## R\n\n\n\n::: {.cell}\n\n```{.r .cell-code}\n\nreviews |>\n llm_sentiment(review, options = c(\"positive\", \"negative\")) |>\n filter(.sentiment == \"negative\")\n#> # A tibble: 2 × 2\n#> review .sentiment\n#> | review | sentiment |
|---|---|
| str | str |
| "This has been the best TV I've… | "positive" |
| "I regret buying this laptop. I… | "negative" |
| "Not sure how to feel about my … | "negative" |
\nshape: (2, 2)
\n```\n\n:::\n:::\n\n\n\n:::\n\n### Summarize\n\nThere may be a need to reduce the number of words in a given text. Typically to \nmake it easier to understand its intent. The function has an argument to \ncontrol the maximum number of words to output \n(`max_words`):\n\n::: {.panel-tabset group=\"language\"}\n## R\n\n\n\n::: {.cell}\n\n```{.r .cell-code}\n\n\nreviews |>\n llm_summarize(review, max_words = 5)\n#> # A tibble: 3 × 2\n#> review .summary \n#> | review | sentiment |
|---|---|
| str | str |
| "I regret buying this laptop. I… | "negative" |
| "Not sure how to feel about my … | "negative" |
\nshape: (3, 2)
\n```\n\n:::\n:::\n\n\n\n:::\n\nTo control the name of the prediction field, you can change `pred_name` argument.\n**This works with the other `llm` functions as well.**\n\n::: {.panel-tabset group=\"language\"}\n## R\n\n\n\n::: {.cell}\n\n```{.r .cell-code}\n\nreviews |>\n llm_summarize(review, max_words = 5, pred_name = \"review_summary\")\n#> # A tibble: 3 × 2\n#> review review_summary \n#> | review | summary |
|---|---|
| str | str |
| "This has been the best TV I've… | "it's a great tv" |
| "I regret buying this laptop. I… | "laptop not worth the money" |
| "Not sure how to feel about my … | "feeling uncertain about new pu… |
\nshape: (3, 2)
\n```\n\n:::\n:::\n\n\n\n:::\n\n### Classify\n\nUse the LLM to categorize the text into one of the options you provide: \n\n\n::: {.panel-tabset group=\"language\"}\n## R\n\n\n\n::: {.cell}\n\n```{.r .cell-code}\nreviews |>\n llm_classify(review, c(\"appliance\", \"computer\"))\n#> # A tibble: 3 × 2\n#> review .classify\n#> | review | review_summary |
|---|---|
| str | str |
| "This has been the best TV I've… | "it's a great tv" |
| "I regret buying this laptop. I… | "laptop not worth the money" |
| "Not sure how to feel about my … | "feeling uncertain about new pu… |
\nshape: (3, 2)
\n```\n\n:::\n:::\n\n\n\n:::\n\n### Extract \n\nOne of the most interesting use cases Using natural language, we can tell the \nLLM to return a specific part of the text. In the following example, we request\nthat the LLM return the product being referred to. We do this by simply saying \n\"product\". The LLM understands what we *mean* by that word, and looks for that\nin the text.\n\n\n::: {.panel-tabset group=\"language\"}\n## R\n\n\n\n::: {.cell}\n\n```{.r .cell-code}\nreviews |>\n llm_extract(review, \"product\")\n#> # A tibble: 3 × 2\n#> review .extract \n#> | review | classify |
|---|---|
| str | str |
| "This has been the best TV I've… | "appliance" |
| "I regret buying this laptop. I… | "appliance" |
| "Not sure how to feel about my … | "appliance" |
\nshape: (3, 2)
\n```\n\n:::\n:::\n\n\n\n:::\n\n\n### Translate\n\nAs the title implies, this function will translate the text into a specified \nlanguage. What is really nice, it is that you don't need to specify the language\nof the source text. Only the target language needs to be defined. The translation\naccuracy will depend on the LLM\n\n::: {.panel-tabset group=\"language\"}\n## R\n\n\n\n::: {.cell}\n\n```{.r .cell-code}\n\n\nreviews |>\n llm_translate(review, \"spanish\")\n#> # A tibble: 3 × 2\n#> review .translation \n#> | review | extract |
|---|---|
| str | str |
| "This has been the best TV I've… | "tv" |
| "I regret buying this laptop. I… | "laptop" |
| "Not sure how to feel about my … | "washing machine" |
\nshape: (3, 2)
\n```\n\n:::\n:::\n\n\n\n:::\n\n### Custom prompt\n\nIt is possible to pass your own prompt to the LLM, and have `mall` run it \nagainst each text entry:\n\n\n::: {.panel-tabset group=\"language\"}\n## R\n\n\n\n::: {.cell}\n\n```{.r .cell-code}\nmy_prompt <- paste(\n \"Answer a question.\",\n \"Return only the answer, no explanation\",\n \"Acceptable answers are 'yes', 'no'\",\n \"Answer this about the following text, is this a happy customer?:\"\n)\n\nreviews |>\n llm_custom(review, my_prompt)\n#> # A tibble: 3 × 2\n#> review .pred\n#> | review | translation |
|---|---|
| str | str |
| "This has been the best TV I've… | "Esta ha sido la mejor TV que h… |
| "I regret buying this laptop. I… | "Lo lamento comprar este portát… |
| "Not sure how to feel about my … | "No estoy seguro de cómo sentir… |
\nshape: (3, 2)
\n```\n\n:::\n:::\n\n\n\n:::\n\n## Model selection and settings\n\nYou can set the model and its options to use when calling the LLM. In this case,\nwe refer to options as model specific things that can be set, such as seed or\ntemperature. \n\n::: {.panel-tabset group=\"language\"}\n## R\n\nInvoking an `llm` function will automatically initialize a model selection\nif you don't have one selected yet. If there is only one option, it will \npre-select it for you. If there are more than one available models, then `mall`\nwill present you as menu selection so you can select which model you wish to \nuse.\n\nCalling `llm_use()` directly will let you specify the model and backend to use.\nYou can also setup additional arguments that will be passed down to the \nfunction that actually runs the prediction. In the case of Ollama, that function\nis [`chat()`](https://hauselin.github.io/ollama-r/reference/chat.html). \n\nThe model to use, and other options can be set for the current R session\n\n\n\n::: {.cell}\n\n```{.r .cell-code}\nllm_use(\"ollama\", \"llama3.2\", seed = 100, temperature = 0)\n```\n:::\n\n\n\n\n## python \n\nThe model and options to be used will be defined at the Polars data frame \nobject level. If not passed, the default model will be **llama3.2**.\n\n\n\n::: {.cell}\n\n```{.python .cell-code}\nreviews.llm.use(options = dict(seed = 100))\n```\n:::\n\n\n\n:::\n\n## Key considerations\n\nThe main consideration is **cost**. Either, time cost, or money cost.\n\nIf using this method with an LLM locally available, the cost will be a long \nrunning time. Unless using a very specialized LLM, a given LLM is a general model. \nIt was fitted using a vast amount of data. So determining a response for each \nrow, takes longer than if using a manually created NLP model. The default model\nused in Ollama is [Llama 3.2](https://ollama.com/library/llama3.2), \nwhich was fitted using 3B parameters. \n\nIf using an external LLM service, the consideration will need to be for the \nbilling costs of using such service. Keep in mind that you will be sending a lot\nof data to be evaluated. \n\nAnother consideration is the novelty of this approach. Early tests are \nproviding encouraging results. But you, as an user, will still need to keep\nin mind that the predictions will not be infallible, so always check the output.\nAt this time, I think the best use for this method, is for a quick analysis.\n\n## Performance\n\nWe will briefly cover this methods performance from two perspectives: \n\n- How long the analysis takes to run locally \n\n- How well it predicts \n\nTo do so, we will use the `data_bookReviews` data set, provided by the `classmap`\npackage. For this exercise, only the first 100, of the total 1,000, are going\nto be part of this analysis.\n\n\n\n::: {.cell}\n\n```{.r .cell-code}\nlibrary(classmap)\n\ndata(data_bookReviews)\n\ndata_bookReviews |>\n glimpse()\n#> Rows: 1,000\n#> Columns: 2\n#> $ review | review | custom |
|---|---|
| str | str |
| "This has been the best TV I've… | "Yes" |
| "I regret buying this laptop. I… | "No" |
| "Not sure how to feel about my … | "No" |
+
+Run multiple LLM predictions against a data frame. The predictions are processed
+row-wise over a specified column. It works using a pre-determined one-shot prompt,
+along with the current row's content. `mall` has been implemented for both R
+and Python. The prompt that is use will depend of the type of analysis needed.
+
+Currently, the included prompts perform the following:
+
+- [Sentiment analysis](#sentiment)
+- [Text summarizing](#summarize)
+- [Classify text](#classify)
+- [Extract one, or several](#extract), specific pieces information from the text
+- [Translate text](#translate)
+- [Custom prompt](#custom-prompt)
+
+This package is inspired by the SQL AI functions now offered by vendors such as
+[Databricks](https://docs.databricks.com/en/large-language-models/ai-functions.html)
+and Snowflake. `mall` uses [Ollama](https://ollama.com/) to interact with LLMs
+installed locally.
+
+
+For R, that interaction takes place via the
+[`ollamar`](https://hauselin.github.io/ollama-r/) package. The functions are
+designed to easily work with piped commands, such as `dplyr`.
+
+```r
+reviews |>
+ llm_sentiment(review)
+```
+
+
+For Python, `mall` includes an extension to [Polars](https://pola.rs/). To
+interact with Ollama, it uses the official [Python library](https://github.com/ollama/ollama-python).
+
+```python
+reviews.llm.sentiment("review")
+```
+
+## Motivation
+
+We want to new find ways to help data scientists use LLMs in their daily work.
+Unlike the familiar interfaces, such as chatting and code completion, this interface
+runs your text data directly against the LLM.
+
+The LLM's flexibility, allows for it to adapt to the subject of your data, and
+provide surprisingly accurate predictions. This saves the data scientist the
+need to write and tune an NLP model.
+
+In recent times, the capabilities of LLMs that can run locally in your computer
+have increased dramatically. This means that these sort of analysis can run
+in your machine with good accuracy. Additionally, it makes it possible to take
+advantage of LLM's at your institution, since the data will not leave the
+corporate network.
+
+## Get started
+
+- Install `mall` from Github
+
+
+::: {.panel-tabset group="language"}
+## R
+```r
+pak::pak("edgararuiz/mall/r")
+```
+
+## python
+```python
+pip install "mall @ git+https://git@github.com/edgararuiz/mall.git#subdirectory=python"
+```
+:::
+
+
+### With local LLMs
+
+- [Download Ollama from the official website](https://ollama.com/download)
+
+- Install and start Ollama in your computer
+
+
+::: {.panel-tabset group="language"}
+## R
+- Install Ollama in your machine. The `ollamar` package's website provides this
+[Installation guide](https://hauselin.github.io/ollama-r/#installation)
+
+- Download an LLM model. For example, I have been developing this package using
+Llama 3.2 to test. To get that model you can run:
+ ```r
+ ollamar::pull("llama3.2")
+ ```
+
+## python
+
+- Install the official Ollama library
+ ```python
+ pip install ollama
+ ```
+
+- Download an LLM model. For example, I have been developing this package using
+Llama 3.2 to test. To get that model you can run:
+ ```python
+ import ollama
+ ollama.pull('llama3.2')
+ ```
+:::
+
+
+
+### With Databricks (R only)
+
+If you pass a table connected to **Databricks** via `odbc`, `mall` will
+automatically use Databricks' LLM instead of Ollama. *You won't need Ollama
+installed if you are using Databricks only.*
+
+`mall` will call the appropriate SQL AI function. For more information see our
+[Databricks article.](https://edgararuiz.github.io/mall/articles/databricks.html)
+
+## LLM functions
+
+### Sentiment
+
+Primarily, `mall` provides verb-like functions that expect a data frame as
+their first argument.
+
+We will start with loading a very small data set contained in `mall`. It has
+3 product reviews that we will use as the source of our examples.
+
+::: {.panel-tabset group="language"}
+## R
+
+```{r}
+library(mall)
+
+data("reviews")
+
+reviews
+```
+
+## python
+
+```{python}
+#| eval: true
+import mall
+import polars as pl
+
+data = mall.MallData
+
+reviews = data.reviews
+reviews
+```
+:::
+
+```{python}
+#| include: false
+
+
+reviews.llm.use(options = dict(seed = 100), _cache = "_readme_cache")
+```
+
+For the first example, we'll asses the sentiment of each review:
+
+::: {.panel-tabset group="language"}
+## R
+
+```{r}
+
+reviews |>
+ llm_sentiment(review)
+```
+
+## python
+
+```{python}
+
+reviews.llm.sentiment("review")
+```
+
+:::
+
+We can also provide custom sentiment labels. Use the `options` argument to control
+that:
+
+::: {.panel-tabset group="language"}
+## R
+
+```{r}
+
+reviews |>
+ llm_sentiment(review, options = c("positive", "negative"))
+```
+
+## python
+
+```{python}
+
+reviews.llm.sentiment("review", options=["positive", "negative"])
+```
+
+:::
+
+As mentioned before, these functions are create to play well with the rest of
+the analysis
+
+::: {.panel-tabset group="language"}
+## R
+
+```{r}
+
+reviews |>
+ llm_sentiment(review, options = c("positive", "negative")) |>
+ filter(.sentiment == "negative")
+```
+
+## python
+
+```{python}
+
+x = reviews.llm.sentiment("review", options=["positive", "negative"])
+
+x.filter(pl.col("sentiment") == "negative")
+
+```
+
+:::
+
+### Summarize
+
+There may be a need to reduce the number of words in a given text. Typically to
+make it easier to understand its intent. The function has an argument to
+control the maximum number of words to output
+(`max_words`):
+
+::: {.panel-tabset group="language"}
+## R
+
+```{r}
+
+
+reviews |>
+ llm_summarize(review, max_words = 5)
+```
+
+## python
+
+```{python}
+
+
+reviews.llm.summarize("review", 5)
+```
+
+:::
+
+To control the name of the prediction field, you can change `pred_name` argument.
+**This works with the other `llm` functions as well.**
+
+::: {.panel-tabset group="language"}
+## R
+
+```{r}
+
+reviews |>
+ llm_summarize(review, max_words = 5, pred_name = "review_summary")
+```
+
+## python
+
+```{python}
+
+reviews.llm.summarize("review", max_words = 5, pred_name = "review_summary")
+```
+
+:::
+
+### Classify
+
+Use the LLM to categorize the text into one of the options you provide:
+
+
+::: {.panel-tabset group="language"}
+## R
+
+```{r}
+reviews |>
+ llm_classify(review, c("appliance", "computer"))
+```
+
+
+## python
+
+```{python}
+
+reviews.llm.classify("review", ["computer", "appliance"])
+```
+
+:::
+
+### Extract
+
+One of the most interesting use cases Using natural language, we can tell the
+LLM to return a specific part of the text. In the following example, we request
+that the LLM return the product being referred to. We do this by simply saying
+"product". The LLM understands what we *mean* by that word, and looks for that
+in the text.
+
+
+::: {.panel-tabset group="language"}
+## R
+
+```{r}
+reviews |>
+ llm_extract(review, "product")
+```
+
+
+## python
+
+```{python}
+
+reviews.llm.extract("review", "product")
+```
+
+:::
+
+
+### Translate
+
+As the title implies, this function will translate the text into a specified
+language. What is really nice, it is that you don't need to specify the language
+of the source text. Only the target language needs to be defined. The translation
+accuracy will depend on the LLM
+
+::: {.panel-tabset group="language"}
+## R
+
+```{r}
+
+
+reviews |>
+ llm_translate(review, "spanish")
+```
+
+
+## python
+
+```{python}
+
+
+reviews.llm.translate("review", "spanish")
+```
+
+:::
+
+### Custom prompt
+
+It is possible to pass your own prompt to the LLM, and have `mall` run it
+against each text entry:
+
+
+::: {.panel-tabset group="language"}
+## R
+
+```{r}
+my_prompt <- paste(
+ "Answer a question.",
+ "Return only the answer, no explanation",
+ "Acceptable answers are 'yes', 'no'",
+ "Answer this about the following text, is this a happy customer?:"
+)
+
+reviews |>
+ llm_custom(review, my_prompt)
+```
+
+
+## python
+
+```{python}
+
+my_prompt = "Answer a question." \
+ + "Return only the answer, no explanation" \
+ + "Acceptable answers are 'yes', 'no'" \
+ + "Answer this about the following text, is this a happy customer?:"
+
+
+reviews.llm.custom("review", prompt = my_prompt)
+```
+
+:::
+
+## Model selection and settings
+
+You can set the model and its options to use when calling the LLM. In this case,
+we refer to options as model specific things that can be set, such as seed or
+temperature.
+
+::: {.panel-tabset group="language"}
+## R
+
+Invoking an `llm` function will automatically initialize a model selection
+if you don't have one selected yet. If there is only one option, it will
+pre-select it for you. If there are more than one available models, then `mall`
+will present you as menu selection so you can select which model you wish to
+use.
+
+Calling `llm_use()` directly will let you specify the model and backend to use.
+You can also setup additional arguments that will be passed down to the
+function that actually runs the prediction. In the case of Ollama, that function
+is [`chat()`](https://hauselin.github.io/ollama-r/reference/chat.html).
+
+The model to use, and other options can be set for the current R session
+
+```{r}
+#| eval: false
+llm_use("ollama", "llama3.2", seed = 100, temperature = 0)
+```
+
+
+## python
+
+The model and options to be used will be defined at the Polars data frame
+object level. If not passed, the default model will be **llama3.2**.
+
+```{python}
+#| eval: false
+reviews.llm.use(options = dict(seed = 100))
+```
+
+:::
+
+## Key considerations
+
+The main consideration is **cost**. Either, time cost, or money cost.
+
+If using this method with an LLM locally available, the cost will be a long
+running time. Unless using a very specialized LLM, a given LLM is a general model.
+It was fitted using a vast amount of data. So determining a response for each
+row, takes longer than if using a manually created NLP model. The default model
+used in Ollama is [Llama 3.2](https://ollama.com/library/llama3.2),
+which was fitted using 3B parameters.
+
+If using an external LLM service, the consideration will need to be for the
+billing costs of using such service. Keep in mind that you will be sending a lot
+of data to be evaluated.
+
+Another consideration is the novelty of this approach. Early tests are
+providing encouraging results. But you, as an user, will still need to keep
+in mind that the predictions will not be infallible, so always check the output.
+At this time, I think the best use for this method, is for a quick analysis.
+
+## Performance
+
+We will briefly cover this methods performance from two perspectives:
+
+- How long the analysis takes to run locally
+
+- How well it predicts
+
+To do so, we will use the `data_bookReviews` data set, provided by the `classmap`
+package. For this exercise, only the first 100, of the total 1,000, are going
+to be part of this analysis.
+
+```{r}
+library(classmap)
+
+data(data_bookReviews)
+
+data_bookReviews |>
+ glimpse()
+```
+As per the docs, `sentiment` is a factor indicating the sentiment of the review:
+negative (1) or positive (2)
+
+```{r}
+length(strsplit(paste(head(data_bookReviews$review, 100), collapse = " "), " ")[[1]])
+```
+
+Just to get an idea of how much data we're processing, I'm using a very, very
+simple word count. So we're analyzing a bit over 20 thousand words.
+
+```{r}
+reviews_llm <- data_bookReviews |>
+ head(100) |>
+ llm_sentiment(
+ col = review,
+ options = c("positive" ~ 2, "negative" ~ 1),
+ pred_name = "predicted"
+ )
+```
+
+As far as **time**, on my Apple M3 machine, it took about 1.5 minutes to process,
+100 rows, containing 20 thousand words. Setting `temp` to 0 in `llm_use()`,
+made the model run faster.
+
+The package uses `purrr` to send each prompt individually to the LLM. But, I did
+try a few different ways to speed up the process, unsuccessfully:
+
+- Used `furrr` to send multiple requests at a time. This did not work because
+either the LLM or Ollama processed all my requests serially. So there was
+no improvement.
+
+- I also tried sending more than one row's text at a time. This cause instability
+in the number of results. For example sending 5 at a time, sometimes returned 7
+or 8. Even sending 2 was not stable.
+
+This is what the new table looks like:
+
+```{r}
+reviews_llm
+```
+
+I used `yardstick` to see how well the model performed. Of course, the accuracy
+will not be of the "truth", but rather the package's results recorded in
+`sentiment`.
+
+```{r}
+library(forcats)
+
+reviews_llm |>
+ mutate(predicted = as.factor(predicted)) |>
+ yardstick::accuracy(sentiment, predicted)
+```
+
+## Vector functions (R only)
+
+`mall` includes functions that expect a vector, instead of a table, to run the
+predictions. This should make it easier to test things, such as custom prompts
+or results of specific text. Each `llm_` function has a corresponding `llm_vec_`
+function:
+
+```{r}
+llm_vec_sentiment("I am happy")
+```
+
+```{r}
+llm_vec_translate("Este es el mejor dia!", "english")
+```
+
diff --git a/objects.json b/objects.json
new file mode 100644
index 0000000..9d36587
--- /dev/null
+++ b/objects.json
@@ -0,0 +1 @@
+{"project": "mall", "version": "0.0.9999", "count": 4, "items": [{"name": "mall.MallFrame.translate", "domain": "py", "role": "function", "priority": "1", "uri": "reference/MallFrame.html#mall.MallFrame.translate", "dispname": "-"}, {"name": "mall.polars.MallFrame.translate", "domain": "py", "role": "function", "priority": "1", "uri": "reference/MallFrame.html#mall.MallFrame.translate", "dispname": "mall.MallFrame.translate"}, {"name": "mall.MallFrame", "domain": "py", "role": "class", "priority": "1", "uri": "reference/MallFrame.html#mall.MallFrame", "dispname": "-"}, {"name": "mall.polars.MallFrame", "domain": "py", "role": "class", "priority": "1", "uri": "reference/MallFrame.html#mall.MallFrame", "dispname": "mall.MallFrame"}]}
\ No newline at end of file
diff --git a/python/MANIFEST.in b/python/MANIFEST.in
new file mode 100644
index 0000000..c08dce5
--- /dev/null
+++ b/python/MANIFEST.in
@@ -0,0 +1 @@
+graft mall
diff --git a/python/README.md b/python/README.md
new file mode 100644
index 0000000..18194a4
--- /dev/null
+++ b/python/README.md
@@ -0,0 +1,100 @@
+# mall
+
+## Intro
+
+Run multiple LLM predictions against a data frame. The predictions are
+processed row-wise over a specified column. It works using a
+pre-determined one-shot prompt, along with the current row’s content.
+
+## Install
+
+To install from Github, use:
+
+``` python
+pip install "mall @ git+https://git@github.com/edgararuiz/mall.git@python#subdirectory=python"
+```
+
+## Examples
+
+``` python
+import mall
+import polars as pl
+
+reviews = pl.DataFrame(
+ data=[
+ "This has been the best TV I've ever used. Great screen, and sound.",
+ "I regret buying this laptop. It is too slow and the keyboard is too noisy",
+ "Not sure how to feel about my new washing machine. Great color, but hard to figure"
+ ],
+ schema=[("review", pl.String)],
+)
+```
+
+## Sentiment
+
+
+``` python
+reviews.llm.sentiment("review")
+```
+
+shape: (3, 2)
+
+| review | sentiment |
+|----------------------------------|------------|
+| str | str |
+| "This has been the best TV I've… | "positive" |
+| "I regret buying this laptop. I… | "negative" |
+| "Not sure how to feel about my … | "neutral" |
+
+## Summarize
+
+``` python
+reviews.llm.summarize("review", 5)
+```
+
+shape: (3, 2)
+
+| review | summary |
+|----------------------------------|----------------------------------|
+| str | str |
+| "This has been the best TV I've… | "it's a great tv" |
+| "I regret buying this laptop. I… | "laptop not worth the money" |
+| "Not sure how to feel about my … | "feeling uncertain about new pu… |
+
+## Translate (as in ‘English to French’)
+
+``` python
+reviews.llm.translate("review", "spanish")
+```
+
+shape: (3, 2)
+
+| review | translation |
+|----------------------------------|----------------------------------|
+| str | str |
+| "This has been the best TV I've… | "Esta ha sido la mejor TV que h… |
+| "I regret buying this laptop. I… | "Lo lamento comprar este portát… |
+| "Not sure how to feel about my … | "No estoy seguro de cómo sentir… |
+
+## Classify
+
+``` python
+reviews.llm.classify("review", ["computer", "appliance"])
+```
+
+shape: (3, 2)
+
+| review | classify |
+|----------------------------------|-------------|
+| str | str |
+| "This has been the best TV I've… | "appliance" |
+| "I regret buying this laptop. I… | "appliance" |
+| "Not sure how to feel about my … | "appliance" |
+
+## LLM session setup
+
+``` python
+reviews.llm.use(options = dict(seed = 100))
+```
+
+ {'backend': 'ollama', 'model': 'llama3.2', 'options': {'seed': 100}}
diff --git a/python/README.qmd b/python/README.qmd
new file mode 100644
index 0000000..862f56a
--- /dev/null
+++ b/python/README.qmd
@@ -0,0 +1,71 @@
+---
+format: gfm
+---
+
+# mall
+
+## Intro
+
+Run multiple LLM predictions against a data frame. The predictions are processed row-wise over a specified column. It works using a pre-determined one-shot prompt, along with the current row’s content.
+
+## Install
+
+To install from Github, use:
+
+```python
+pip install "mall @ git+https://git@github.com/edgararuiz/mall.git@python#subdirectory=python"
+```
+
+## Examples
+
+```{python}
+#| include: false
+import polars as pl
+from polars.dataframe._html import HTMLFormatter
+html_formatter = get_ipython().display_formatter.formatters['text/html']
+html_formatter.for_type(pl.DataFrame, lambda df: "\n".join(HTMLFormatter(df).render()))
+```
+
+
+```{python}
+import mall
+import polars as pl
+data = mall.MallData
+reviews = data.reviews
+```
+
+```{python}
+#| include: false
+reviews.llm.use(options = dict(seed = 100))
+```
+
+
+## Sentiment
+
+```{python}
+reviews.llm.sentiment("review")
+```
+
+## Summarize
+
+```{python}
+reviews.llm.summarize("review", 5)
+```
+
+## Translate (as in 'English to French')
+
+```{python}
+reviews.llm.translate("review", "spanish")
+```
+
+## Classify
+
+```{python}
+reviews.llm.classify("review", ["computer", "appliance"])
+```
+
+## LLM session setup
+
+```{python}
+reviews.llm.use(options = dict(seed = 100))
+```
diff --git a/python/mall/__init__.py b/python/mall/__init__.py
new file mode 100644
index 0000000..e623439
--- /dev/null
+++ b/python/mall/__init__.py
@@ -0,0 +1,4 @@
+__all__ = ["MallFrame", "MallData"]
+
+from mall.polars import MallFrame
+from mall.data import MallData
diff --git a/python/mall/data.py b/python/mall/data.py
new file mode 100644
index 0000000..73b7b23
--- /dev/null
+++ b/python/mall/data.py
@@ -0,0 +1,12 @@
+import polars as pl
+
+
+class MallData:
+ reviews = pl.DataFrame(
+ data=[
+ "This has been the best TV I've ever used. Great screen, and sound.",
+ "I regret buying this laptop. It is too slow and the keyboard is too noisy",
+ "Not sure how to feel about my new washing machine. Great color, but hard to figure",
+ ],
+ schema=[("review", pl.String)],
+ )
diff --git a/python/mall/llm.py b/python/mall/llm.py
new file mode 100644
index 0000000..dc89ee3
--- /dev/null
+++ b/python/mall/llm.py
@@ -0,0 +1,84 @@
+import ollama
+import json
+import hashlib
+import os
+
+
+def build_msg(x, msg):
+ out = []
+ for msgs in msg:
+ out.append({"role": msgs["role"], "content": msgs["content"].format(x)})
+ return out
+
+
+def llm_call(x, msg, use, preview=False, valid_resps=""):
+
+ call = dict(
+ model=use.get("model"),
+ messages=build_msg(x, msg),
+ options=use.get("options"),
+ )
+
+ if preview:
+ print(call)
+
+ cache = ""
+ if use.get("_cache") != "":
+ hash_call = build_hash(call)
+ cache = cache_check(hash_call, use)
+
+ if cache == "":
+ resp = ollama.chat(
+ model=use.get("model"),
+ messages=build_msg(x, msg),
+ options=use.get("options"),
+ )
+ out = resp["message"]["content"]
+ else:
+ out = cache
+
+ if use.get("_cache") != "":
+ if cache == "":
+ cache_record(hash_call, use, call, out)
+
+ if isinstance(valid_resps, list):
+ if out not in valid_resps:
+ out = None
+ return out
+
+
+def build_hash(x):
+ if isinstance(x, dict):
+ x = json.dumps(x)
+ x_sha = hashlib.sha1(x.encode("utf-8"))
+ x_digest = x_sha.hexdigest()
+ return x_digest
+
+
+def cache_check(hash_call, use):
+ file_path = cache_path(hash_call, use)
+ if os.path.isfile(file_path):
+ file_connection = open(file_path)
+ file_read = file_connection.read()
+ file_parse = json.loads(file_read)
+ out = file_parse.get("response")
+ else:
+ out = ""
+ return out
+
+
+def cache_record(hash_call, use, call, response):
+ file_path = cache_path(hash_call, use)
+ file_folder = os.path.dirname(file_path)
+ if not os.path.isdir(file_folder):
+ os.makedirs(file_folder)
+ contents = dict(request=call, response=response)
+ json_contents = json.dumps(contents)
+ with open(file_path, "w") as file:
+ file.write(json_contents)
+
+
+def cache_path(hash_call, use):
+ sub_folder = hash_call[0:2]
+ file_path = use.get("_cache") + "/" + sub_folder + "/" + hash_call + ".json"
+ return file_path
diff --git a/python/mall/polars.py b/python/mall/polars.py
new file mode 100644
index 0000000..e7aff5b
--- /dev/null
+++ b/python/mall/polars.py
@@ -0,0 +1,156 @@
+import polars as pl
+from mall.prompt import sentiment, summarize, translate, classify, extract, custom
+from mall.llm import llm_call
+
+
+@pl.api.register_dataframe_namespace("llm")
+class MallFrame:
+ """Extension to Polars that add ability to use
+ an LLM to run batch predictions over a data frame
+ """
+
+ def __init__(self, df: pl.DataFrame) -> None:
+ self._df = df
+ self._use = dict(
+ backend = "ollama",
+ model = "llama3.2",
+ _cache = "_mall_cache"
+ )
+
+ def use(self, backend="", model="", _cache = "_mall_cache", **kwargs):
+ if backend != "":
+ self._use.update(dict(backend = backend))
+ if model != "":
+ self._use.update(dict(model = model))
+ self._use.update(dict(_cache = _cache))
+ self._use.update(dict(kwargs))
+ return self._use
+
+ def sentiment(
+ self,
+ col,
+ options=["positive", "negative", "neutral"],
+ additional="",
+ pred_name="sentiment",
+ ) -> list[pl.DataFrame]:
+ df = map_call(
+ df=self._df,
+ col=col,
+ msg=sentiment(options, additional=additional),
+ pred_name=pred_name,
+ use=self._use,
+ valid_resps=options,
+ )
+ return df
+
+ def summarize(
+ self,
+ col,
+ max_words=10,
+ additional="",
+ pred_name="summary",
+ ) -> list[pl.DataFrame]:
+ df = map_call(
+ df=self._df,
+ col=col,
+ msg=summarize(max_words, additional=additional),
+ pred_name=pred_name,
+ use=self._use,
+ )
+ return df
+
+ def translate(
+ self,
+ col,
+ language="",
+ additional="",
+ pred_name="translation",
+ ) -> list[pl.DataFrame]:
+ """Translate text into another language.
+
+ Parameters
+ ------
+ col: str
+ The name of the text field to process
+
+ language: str
+ The target language to translate to. For example 'French'.
+
+ pred_name: str
+ A character vector with the name of the new column where the
+ prediction will be placed
+
+ additional: str
+ Inserts this text into the prompt sent to the LLM
+ """
+ df = map_call(
+ df=self._df,
+ col=col,
+ msg=translate(language, additional=additional),
+ pred_name=pred_name,
+ use=self._use,
+ )
+ return df
+
+ def classify(
+ self,
+ col,
+ labels="",
+ additional="",
+ pred_name="classify",
+ ) -> list[pl.DataFrame]:
+ df = map_call(
+ df=self._df,
+ col=col,
+ msg=classify(labels, additional=additional),
+ pred_name=pred_name,
+ use=self._use,
+ valid_resps=labels,
+ )
+ return df
+
+ def extract(
+ self,
+ col,
+ labels="",
+ additional="",
+ pred_name="extract",
+ ) -> list[pl.DataFrame]:
+ df = map_call(
+ df=self._df,
+ col=col,
+ msg=extract(labels, additional=additional),
+ pred_name=pred_name,
+ use=self._use,
+ valid_resps=labels,
+ )
+ return df
+
+ def custom(
+ self,
+ col,
+ prompt="",
+ valid_resps="",
+ pred_name="custom",
+ ) -> list[pl.DataFrame]:
+ df = map_call(
+ df=self._df,
+ col=col,
+ msg=custom(prompt),
+ pred_name=pred_name,
+ use=self._use,
+ valid_resps=valid_resps,
+ )
+ return df
+
+
+def map_call(df, col, msg, pred_name, use, valid_resps=""):
+ df = df.with_columns(
+ pl.col(col)
+ .map_elements(
+ lambda x: llm_call(x, msg, use, False, valid_resps),
+ return_dtype=pl.String,
+ )
+ .alias(pred_name)
+ )
+ return df
diff --git a/python/mall/prompt.py b/python/mall/prompt.py
new file mode 100644
index 0000000..cd7510a
--- /dev/null
+++ b/python/mall/prompt.py
@@ -0,0 +1,122 @@
+def process_labels(x, if_list="", if_dict=""):
+ if isinstance(x, list):
+ out = ""
+ for i in x:
+ out += " " + i
+ out = out.strip()
+ out = out.replace(" ", ", ")
+ out = if_list.replace("{values}", out)
+ if isinstance(x, dict):
+ out = ""
+ for i in x:
+ new = if_dict
+ new = new.replace("{key}", i)
+ new = new.replace("{value}", x.get(i))
+ out += " " + new
+ return out
+
+
+def sentiment(options, additional=""):
+ new_options = process_labels(
+ options,
+ "Return only one of the following answers: {values}",
+ "- If the text is {key}, return {value}",
+ )
+ msg = [
+ {
+ "role": "user",
+ "content": "You are a helpful sentiment engine. "
+ + f"{new_options}. "
+ + "No capitalization. No explanations. "
+ + f"{additional} "
+ + "The answer is based on the following text:\n{}",
+ }
+ ]
+ return msg
+
+
+def summarize(max_words, additional=""):
+ msg = [
+ {
+ "role": "user",
+ "content": "You are a helpful summarization engine."
+ + "Your answer will contain no no capitalization and no explanations."
+ + f"Return no more than "
+ + str(max_words)
+ + " words."
+ + f"{additional}"
+ + "The answer is the summary of the following text:\n{}",
+ }
+ ]
+ return msg
+
+
+def translate(language, additional=""):
+ msg = [
+ {
+ "role": "user",
+ "content": "You are a helpful translation engine."
+ + "You will return only the translation text, no explanations."
+ + f"The target language to translate to is: {language}."
+ + f"{additional}"
+ + "The answer is the translation of the following text:\n{}",
+ }
+ ]
+ return msg
+
+
+def classify(labels, additional=""):
+ new_labels = process_labels(
+ labels,
+ "Determine if the text refers to one of the following:{values}",
+ "- If the text is {key}, return {value}",
+ )
+ msg = [
+ {
+ "role": "user",
+ "content": "You are a helpful classification engine. "
+ + f"{new_labels}. "
+ + "No capitalization. No explanations. "
+ + f"{additional} "
+ + "The answer is based on the following text:\n{}",
+ }
+ ]
+ return msg
+
+
+def extract(labels, additional=""):
+ col_labels = ""
+ if isinstance(labels, list):
+ no_labels = len(labels)
+ plural = "s"
+ text_multi = (
+ "Return the response in a simple list, pipe separated, and no headers. "
+ )
+ for label in labels:
+ col_labels += label + " "
+ col_labels = col_labels.rstrip()
+ col_labels = col_labels.replace(" ", ", ")
+ else:
+ no_labels = 1
+ plural = ""
+ text_multi = ""
+ col_labels = labels
+
+ msg = [
+ {
+ "role": "user",
+ "content": "You are a helpful text extraction engine."
+ + f"Extract the {col_labels} being referred to on the text."
+ + f"I expect {no_labels} item{plural} exactly."
+ + "No capitalization. No explanations."
+ + f"{text_multi}"
+ + f"{additional}"
+ + "The answer is based on the following text:\n{}",
+ }
+ ]
+ return msg
+
+
+def custom(prompt):
+ msg = [{"role": "user", "content": f"{prompt}" + ": \n{}"}]
+ return msg
diff --git a/python/pyproject.toml b/python/pyproject.toml
new file mode 100644
index 0000000..277be4c
--- /dev/null
+++ b/python/pyproject.toml
@@ -0,0 +1,14 @@
+[project]
+name = "mall"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+ "ollama>=0.3.3",
+ "polars>=1.9.0",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
diff --git a/python/uv.lock b/python/uv.lock
new file mode 100644
index 0000000..b4ad052
--- /dev/null
+++ b/python/uv.lock
@@ -0,0 +1,120 @@
+version = 1
+requires-python = ">=3.12"
+
+[[package]]
+name = "anyio"
+version = "4.6.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "idna" },
+ { name = "sniffio" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/78/49/f3f17ec11c4a91fe79275c426658e509b07547f874b14c1a526d86a83fc8/anyio-4.6.0.tar.gz", hash = "sha256:137b4559cbb034c477165047febb6ff83f390fc3b20bf181c1fc0a728cb8beeb", size = 170983 }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/9e/ef/7a4f225581a0d7886ea28359179cb861d7fbcdefad29663fc1167b86f69f/anyio-4.6.0-py3-none-any.whl", hash = "sha256:c7d2e9d63e31599eeb636c8c5c03a7e108d73b345f064f1c19fdc87b79036a9a", size = 89631 },
+]
+
+[[package]]
+name = "certifi"
+version = "2024.8.30"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b0/ee/9b19140fe824b367c04c5e1b369942dd754c4c5462d5674002f75c4dedc1/certifi-2024.8.30.tar.gz", hash = "sha256:bec941d2aa8195e248a60b31ff9f0558284cf01a52591ceda73ea9afffd69fd9", size = 168507 }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/12/90/3c9ff0512038035f59d279fddeb79f5f1eccd8859f06d6163c58798b9487/certifi-2024.8.30-py3-none-any.whl", hash = "sha256:922820b53db7a7257ffbda3f597266d435245903d80737e34f8a45ff3e3230d8", size = 167321 },
+]
+
+[[package]]
+name = "h11"
+version = "0.14.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f5/38/3af3d3633a34a3316095b39c8e8fb4853a28a536e55d347bd8d8e9a14b03/h11-0.14.0.tar.gz", hash = "sha256:8f19fbbe99e72420ff35c00b27a34cb9937e902a8b810e2c88300c6f0a3b699d", size = 100418 }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/95/04/ff642e65ad6b90db43e668d70ffb6736436c7ce41fcc549f4e9472234127/h11-0.14.0-py3-none-any.whl", hash = "sha256:e3fe4ac4b851c468cc8363d500db52c2ead036020723024a109d37346efaa761", size = 58259 },
+]
+
+[[package]]
+name = "httpcore"
+version = "1.0.6"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "certifi" },
+ { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b6/44/ed0fa6a17845fb033bd885c03e842f08c1b9406c86a2e60ac1ae1b9206a6/httpcore-1.0.6.tar.gz", hash = "sha256:73f6dbd6eb8c21bbf7ef8efad555481853f5f6acdeaff1edb0694289269ee17f", size = 85180 }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/06/89/b161908e2f51be56568184aeb4a880fd287178d176fd1c860d2217f41106/httpcore-1.0.6-py3-none-any.whl", hash = "sha256:27b59625743b85577a8c0e10e55b50b5368a4f2cfe8cc7bcfa9cf00829c2682f", size = 78011 },
+]
+
+[[package]]
+name = "httpx"
+version = "0.27.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "anyio" },
+ { name = "certifi" },
+ { name = "httpcore" },
+ { name = "idna" },
+ { name = "sniffio" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/78/82/08f8c936781f67d9e6b9eeb8a0c8b4e406136ea4c3d1f89a5db71d42e0e6/httpx-0.27.2.tar.gz", hash = "sha256:f7c2be1d2f3c3c3160d441802406b206c2b76f5947b11115e6df10c6c65e66c2", size = 144189 }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/56/95/9377bcb415797e44274b51d46e3249eba641711cf3348050f76ee7b15ffc/httpx-0.27.2-py3-none-any.whl", hash = "sha256:7bb2708e112d8fdd7829cd4243970f0c223274051cb35ee80c03301ee29a3df0", size = 76395 },
+]
+
+[[package]]
+name = "idna"
+version = "3.10"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f1/70/7703c29685631f5a7590aa73f1f1d3fa9a380e654b86af429e0934a32f7d/idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9", size = 190490 }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442 },
+]
+
+[[package]]
+name = "mall"
+version = "0.1.0"
+source = { editable = "." }
+dependencies = [
+ { name = "ollama" },
+ { name = "polars" },
+]
+
+[package.metadata]
+requires-dist = [
+ { name = "ollama", specifier = ">=0.3.3" },
+ { name = "polars", specifier = ">=1.9.0" },
+]
+
+[[package]]
+name = "ollama"
+version = "0.3.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "httpx" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a6/8e/60a9b065eb796ef3996451cbe2d8044f6b030696166693b9805ae33b8b4c/ollama-0.3.3.tar.gz", hash = "sha256:f90a6d61803117f40b0e8ff17465cab5e1eb24758a473cfe8101aff38bc13b51", size = 10390 }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/6a/ca/d22905ac3f768523f778189d38c9c6cd9edf4fa9dd09cb5a3fc57b184f90/ollama-0.3.3-py3-none-any.whl", hash = "sha256:ca6242ce78ab34758082b7392df3f9f6c2cb1d070a9dede1a4c545c929e16dba", size = 10267 },
+]
+
+[[package]]
+name = "polars"
+version = "1.9.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/53/09/c2fb0b231d551e0c8e68097d08577712bdff1ba91346cda8228e769602f5/polars-1.9.0.tar.gz", hash = "sha256:8e1206ef876f61c1d50a81e102611ea92ee34631cb135b46ad314bfefd3cb122", size = 4027431 }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/64/cc/3d0292048d8f9045a03510aeecda2e6ed9df451ae8853274946ff841f98b/polars-1.9.0-cp38-abi3-macosx_10_12_x86_64.whl", hash = "sha256:a471d2ce96f6fa5dd0ef16bcdb227f3dbe3af8acb776ca52f9e64ef40c7489a0", size = 31870933 },
+ { url = "https://files.pythonhosted.org/packages/ee/be/15af97f4d8b775630da16a8bf0141507d9c0ae5f2637b9a27ed337b3b1ba/polars-1.9.0-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:94b12d731cd200d2c50b13fc070d6353f708e632bca6529c5a72aa6a69e5285d", size = 28171055 },
+ { url = "https://files.pythonhosted.org/packages/bb/57/b286b317f061d8f17bab4726a27e7b185fbf3d3db65cf689074256ea34a9/polars-1.9.0-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f85f132732aa63c6f3b502b0fdfc3ba9f0b78cc6330059b5a2d6f9fd78508acb", size = 33063367 },
+ { url = "https://files.pythonhosted.org/packages/e5/25/bf5d43dcb538bf6573b15f3d5995a52be61b8fbce0cd737e72c4d25eef88/polars-1.9.0-cp38-abi3-manylinux_2_24_aarch64.whl", hash = "sha256:f753c8941a3b3249d59262d68a856714a96a7d4e16977aefbb196be0c192e151", size = 29764698 },
+ { url = "https://files.pythonhosted.org/packages/a6/cf/f9170a3ac20e0efb9d3c1cdacc677e35b711ffd5ec48a6d5f3da7b7d8663/polars-1.9.0-cp38-abi3-win_amd64.whl", hash = "sha256:95de07066cd797dd940fa2783708a7bef93c827a57be0f4dfad3575a6144212b", size = 32819142 },
+]
+
+[[package]]
+name = "sniffio"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372 }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235 },
+]
diff --git a/r/.Rbuildignore b/r/.Rbuildignore
new file mode 100644
index 0000000..91114bf
--- /dev/null
+++ b/r/.Rbuildignore
@@ -0,0 +1,2 @@
+^.*\.Rproj$
+^\.Rproj\.user$
diff --git a/DESCRIPTION b/r/DESCRIPTION
similarity index 100%
rename from DESCRIPTION
rename to r/DESCRIPTION
diff --git a/LICENSE b/r/LICENSE
similarity index 100%
rename from LICENSE
rename to r/LICENSE
diff --git a/LICENSE.md b/r/LICENSE.md
similarity index 100%
rename from LICENSE.md
rename to r/LICENSE.md
diff --git a/NAMESPACE b/r/NAMESPACE
similarity index 100%
rename from NAMESPACE
rename to r/NAMESPACE
diff --git a/R/data-reviews.R b/r/R/data-reviews.R
similarity index 100%
rename from R/data-reviews.R
rename to r/R/data-reviews.R
diff --git a/R/import-standalone-purrr.R b/r/R/import-standalone-purrr.R
similarity index 100%
rename from R/import-standalone-purrr.R
rename to r/R/import-standalone-purrr.R
diff --git a/R/llm-classify.R b/r/R/llm-classify.R
similarity index 100%
rename from R/llm-classify.R
rename to r/R/llm-classify.R
diff --git a/R/llm-custom.R b/r/R/llm-custom.R
similarity index 100%
rename from R/llm-custom.R
rename to r/R/llm-custom.R
diff --git a/R/llm-extract.R b/r/R/llm-extract.R
similarity index 100%
rename from R/llm-extract.R
rename to r/R/llm-extract.R
diff --git a/R/llm-sentiment.R b/r/R/llm-sentiment.R
similarity index 100%
rename from R/llm-sentiment.R
rename to r/R/llm-sentiment.R
diff --git a/R/llm-summarize.R b/r/R/llm-summarize.R
similarity index 100%
rename from R/llm-summarize.R
rename to r/R/llm-summarize.R
diff --git a/R/llm-translate.R b/r/R/llm-translate.R
similarity index 100%
rename from R/llm-translate.R
rename to r/R/llm-translate.R
diff --git a/R/llm-use.R b/r/R/llm-use.R
similarity index 100%
rename from R/llm-use.R
rename to r/R/llm-use.R
diff --git a/R/m-backend-prompt.R b/r/R/m-backend-prompt.R
similarity index 100%
rename from R/m-backend-prompt.R
rename to r/R/m-backend-prompt.R
diff --git a/R/m-backend-submit.R b/r/R/m-backend-submit.R
similarity index 100%
rename from R/m-backend-submit.R
rename to r/R/m-backend-submit.R
diff --git a/R/m-cache.R b/r/R/m-cache.R
similarity index 100%
rename from R/m-cache.R
rename to r/R/m-cache.R
diff --git a/R/m-defaults.R b/r/R/m-defaults.R
similarity index 100%
rename from R/m-defaults.R
rename to r/R/m-defaults.R
diff --git a/R/m-vec-prompt.R b/r/R/m-vec-prompt.R
similarity index 100%
rename from R/m-vec-prompt.R
rename to r/R/m-vec-prompt.R
diff --git a/R/mall.R b/r/R/mall.R
similarity index 100%
rename from R/mall.R
rename to r/R/mall.R
diff --git a/R/utils.R b/r/R/utils.R
similarity index 100%
rename from R/utils.R
rename to r/R/utils.R
diff --git a/README.Rmd b/r/README.Rmd
similarity index 100%
rename from README.Rmd
rename to r/README.Rmd
diff --git a/r/README.md b/r/README.md
new file mode 100644
index 0000000..24dddc1
--- /dev/null
+++ b/r/README.md
@@ -0,0 +1,407 @@
+
+
+
+# mall
+
+
+
+
+
+[](https://github.com/edgararuiz/mall/actions/workflows/R-CMD-check.yaml)
+[](https://app.codecov.io/gh/edgararuiz/mall?branch=main)
+[](https://lifecycle.r-lib.org/articles/stages.html#experimental)
+
+
+## Intro
+
+Run multiple LLM predictions against a data frame. The predictions are
+processed row-wise over a specified column. It works using a
+pre-determined one-shot prompt, along with the current row’s content.
+The prompt that is use will depend of the type of analysis needed.
+Currently, the included prompts perform the following:
+
+- [Sentiment analysis](#sentiment)
+- [Text summarizing](#summarize)
+- [Classify text](#classify)
+- [Extract one, or several](#extract), specific pieces information from
+ the text
+- [Translate text](#translate)
+- [Custom prompt](#custom-prompt)
+
+This package is inspired by the SQL AI functions now offered by vendors
+such as
+[Databricks](https://docs.databricks.com/en/large-language-models/ai-functions.html)
+and Snowflake. `mall` uses [Ollama](https://ollama.com/) to interact
+with LLMs installed locally. That interaction takes place via the
+[`ollamar`](https://hauselin.github.io/ollama-r/) package.
+
+## Motivation
+
+We want to new find ways to help data scientists use LLMs in their daily
+work. Unlike the familiar interfaces, such as chatting and code
+completion, this interface runs your text data directly against the LLM.
+The LLM’s flexibility, allows for it to adapt to the subject of your
+data, and provide surprisingly accurate predictions. This saves the data
+scientist the need to write and tune an NLP model.
+
+## Get started
+
+- Install `mall` from Github
+
+ ``` r
+ pak::pak("edgararuiz/mall")
+ ```
+
+### With local LLMs
+
+- Install Ollama in your machine. The `ollamar` package’s website
+ provides this [Installation
+ guide](https://hauselin.github.io/ollama-r/#installation)
+
+- Download an LLM model. For example, I have been developing this
+ package using Llama 3.2 to test. To get that model you can run:
+
+ ``` r
+ ollamar::pull("llama3.2")
+ ```
+
+### With Databricks
+
+If you pass a table connected to **Databricks** via `odbc`, `mall` will
+automatically use Databricks’ LLM instead of Ollama. *You won’t need
+Ollama installed if you are using Databricks only.*
+
+`mall` will call the appropriate SQL AI function. For more information
+see our [Databricks
+article.](https://edgararuiz.github.io/mall/articles/databricks.html)
+
+## LLM functions
+
+### Sentiment
+
+Primarily, `mall` provides verb-like functions that expect a `tbl` as
+their first argument. This allows us to use them in piped operations.
+
+We will start with loading a very small data set contained in `mall`. It
+has 3 product reviews that we will use as the source of our examples.
+
+``` r
+library(mall)
+
+data("reviews")
+
+reviews
+#> # A tibble: 3 × 1
+#> review
+#> 
+::: {.panel-tabset group="language"}
+## R
+{{< include r_index.qmd >}}
-# Function Reference
+## python
-[llm_classify()](llm_classify.html) [llm_vec_classify()](llm_classify.html)
+
- Categorize data as one of options given
-
-
-[llm_custom()](llm_custom.html) [llm_vec_custom()](llm_custom.html)
-
- Send a custom prompt to the LLM
-
-
-[llm_extract()](llm_extract.html) [llm_vec_extract()](llm_extract.html)
-
- Extract entities from text
-
-
-[llm_sentiment()](llm_sentiment.html) [llm_vec_sentiment()](llm_sentiment.html)
-
- Sentiment analysis
-
-
-[llm_summarize()](llm_summarize.html) [llm_vec_summarize()](llm_summarize.html)
-
- Summarize text
-
-
-[llm_translate()](llm_translate.html) [llm_vec_translate()](llm_translate.html)
-
- Translates text to a specific language
-
-
-[llm_use()](llm_use.html)
-
- Specify the model to use
-
-
-[reviews](reviews.html)
-
- Mini reviews data set
+[MallFrame](MallFrame.qmd#mall.MallFrame)
+ Extension to Polars that add ability to use
+an LLM to run batch predictions over a data frame
+:::
+
\ No newline at end of file
diff --git a/reference/r_index.qmd b/reference/r_index.qmd
new file mode 100644
index 0000000..761cf58
--- /dev/null
+++ b/reference/r_index.qmd
@@ -0,0 +1,45 @@
+---
+toc: false
+---
+
+
+[llm_classify()](llm_classify.html) [llm_vec_classify()](llm_classify.html)
+
+ Categorize data as one of options given
+
+
+[llm_custom()](llm_custom.html) [llm_vec_custom()](llm_custom.html)
+
+ Send a custom prompt to the LLM
+
+
+[llm_extract()](llm_extract.html) [llm_vec_extract()](llm_extract.html)
+
+ Extract entities from text
+
+
+[llm_sentiment()](llm_sentiment.html) [llm_vec_sentiment()](llm_sentiment.html)
+
+ Sentiment analysis
+
+
+[llm_summarize()](llm_summarize.html) [llm_vec_summarize()](llm_summarize.html)
+
+ Summarize text
+
+
+[llm_translate()](llm_translate.html) [llm_vec_translate()](llm_translate.html)
+
+ Translates text to a specific language
+
+
+[llm_use()](llm_use.html)
+
+ Specify the model to use
+
+
+[reviews](reviews.html)
+
+ Mini reviews data set
+
+
diff --git a/utils/website/README.md b/utils/website/README.md
index a0c5076..6b07432 100644
--- a/utils/website/README.md
+++ b/utils/website/README.md
@@ -2,8 +2,8 @@
```r
devtools::install(upgrade = "never")
-try(fs::dir_delete("_freeze/reference/"))
-source("utils/website/build_reference.R")
+#try(fs::dir_delete("_freeze/reference/"))
+source(here::here("utils/website/build_reference.R"))
quarto::quarto_render(as_job = FALSE)
quarto::quarto_preview()
```
diff --git a/utils/website/build_reference.R b/utils/website/build_reference.R
index 674d8ce..afb7fb5 100644
--- a/utils/website/build_reference.R
+++ b/utils/website/build_reference.R
@@ -8,9 +8,9 @@ library(cli)
build_reference_index <- function(pkg = ".", folder = "reference") {
if (is.character(pkg)) pkg <- pkgdown::as_pkgdown(pkg)
try(dir_create(folder))
- ref_path <- path(folder, "index", ext = "qmd")
+ ref_path <- path(folder, "r_index", ext = "qmd")
try(file_delete(ref_path))
- writeLines(reference_index(), ref_path)
+ writeLines(reference_index(pkg), ref_path)
cli_inform(col_green(ref_path))
}
@@ -29,5 +29,5 @@ build_reference <- function(pkg = ".", folder = "reference") {
)
}
-build_reference_index()
-build_reference()
+build_reference_index("r")
+build_reference("r")
diff --git a/utils/website/index-page.R b/utils/website/index-page.R
index d080733..7af798b 100644
--- a/utils/website/index-page.R
+++ b/utils/website/index-page.R
@@ -17,9 +17,7 @@ reference_index <- function(pkg = ".") {
"---",
"toc: false",
"---",
- "![](\"../man/figures/favicon/apple-touch-icon-180x180.png\"){kind=icon}
",
- "",
- "# Function Reference",
+ "![](\"../figures/favicon/apple-touch-icon-76x76.png\"){kind=icon}
",
"",
res
)