https://community.wolfram.com RSS Feed for Wolfram Community showing any discussions tagged with Data Science sorted by active. https://community.wolfram.com/groups/-/m/t/3716766 [![enter image description here][1]](https://resources.wolframcloud.com/PacletRepository/resources/AntonAntonov/Chatnik/) ## Introduction ["Chatnik"](https://resources.wolframcloud.com/PacletRepository/resources/AntonAntonov/Chatnik/), \[AAp9\], is a Wolfram Language (WL) paclet that provides Command Line Interface (CLI) scripts for conversing with multiple, persistent Large Language Model (LLM) personas. Files of the host Operating System (OS) are used to maintain persistence. Most importantly, "Chatnik" does not try to entrench users in its own user experience (loop) for interaction with LLMs. Instead, it brings customizable LLM invocations and conversations into the Unix shell -- making them composable, integratable, and scriptable with existing workflows. In other words, the tag line "LLM Host in the Shell" should be understood as "LLMs, not as an app -- but as a Unix shell primitive." Here are the most notable "Chatnik" features: - Provides UNIX shell pipelining for LLM interactions - Maintains a database of LLM chat objects - Connects to multiple models across different LLM providers - Offers access to a large repository of prompts - Enables convenient retrieval of interaction history - Includes management tools for the LLM chat object database - Preprocesses prompts using a simple domain-specific language (DSL) - Supports loading user-defined LLM personas from JSON files **Remark:** "Chatnik" closely follows the LLM-chat objects interaction system of the Python package ["JupyterChatbook"](https://pypi.org/project/JupyterChatbook/), \[AAp3\], and Raku package ["Jupyter::Chatbook"](https://raku.land/zef:antononcube/Jupyter::Chatbook), \[AAp7\]. Another (remote) resemblance can be found with the Wolfram Language paclet ["Chatbook"](https://resources.wolframcloud.com/PacletRepository/resources/Wolfram/Chatbook/), \[CGp1\]. (In other words, using OS shells instead of Jupyter or Wolfram notebooks.) **Remark:** The WL paclet "Chatnik", \[AAp9\], is a translation of the Raku package ["Chatnik"](https://github.com/antononcube/Raku-Chatnik), \[AAp8\] and the Python package ["Chatnik"](https://pypi.org/project/Chatnik/), \[AAp4\]. The WL CLI scripts are with CamelCase, i.e. `LLMChat`, `LLMChatMeta`, and `LLMPrompt`. The corresponding CLI scripts of the Raku package use kebab-case, i.e. `llm-chat`, `llm-chat-meta`, and `llm-prompt`. The corresponding CLI scripts of the Python package use snake_case, i.e. `llm_chat`, `llm_chat_meta`, and `llm_prompt`. **Remark:** In addition, the Raku package provides the "umbrella" CLI `chatnik`. **Remark:** When the phrase "Chatnik system" is used that is in order to emphasize that there are "Chatnik" packages in several programming languages with (almost) the same design and usage. The rest of this document is organized as follows: - Introductory examples - Why make another LLM-CLI system? - Architectural design - Related and alternative packages ---- ## Introductory examples The examples in this section demonstrate how the CLI scripts `LLMChat` and `LLMChatMeta` -- provided by "Chatnik" -- are used to have multi-turn LLM conversations and compose Unix shell pipelines with LLM interaction messages. **Remark:** In order to use these scripts use the function [`ChatnikCopyScripts`](https://resources.wolframcloud.com/PacletRepository/resources/AntonAntonov/Chatnik/ref/ChatnikCopyScripts.html) after installing "Chatnik". **Remark:** The prompts used in the examples are provided by the [Wolfram Prompt Repository (WPR)](https://resources.wolframcloud.com/PromptRepository/). Many of those prompts are also available in Python and Raku via the packages ["LLMPrompts"](https://pypi.org/project/LLMPrompts), \[AAp2\], and ["LLM::Prompts"](https://raku.land/zef:antononcube/LLM::Prompts), \[AAp6\], respectively. ### Chat with Yoda Here we create an LLM persona -- by naming it and "priming it" with a prompt -- and start interacting with it: ```shell LLMChat 'Hi! Who are you?' --chat-id=yoda --prompt=@Yoda ``` ``` # Yoda, I am. Wise and old Jedi Master, yes. Help you with the Force, I will. Hmm. ``` Here we continue the conversation -- using the `--i` synonym of `--chat-id`: ```shell LLMChat 'How many students did you have?' --i=yoda ``` ``` # Many students, I have trained in my long life. Countless, they are. Luke Skywalker, young Anakin, and others, yes. Teach them the ways of the Force, I did. Hmm. Important balance, training Jedi is. Patience and wisdom, the path to success they are. ``` And continue the discussion some more: ```shell LLMChat 'Which student is the best?' --i=yoda ``` ``` # Best student, difficult to say, it is. Each has strengths and weaknesses, hmmm. Luke Skywalker, strong in the Force he is. Anakin, powerful but troubled, hmmm. Learn from mistakes, all must. Judge by heart and actions, we should. Humble and wise, the true measure of a Jedi is. Yes. ``` The example used the LLM persona ["Yoda"](https://resources.wolframcloud.com/PromptRepository/resources/Yoda). (See more LLM personas [here](https://resources.wolframcloud.com/PromptRepository/category/personas?sortBy=Name).) ### Fortune-echo-limerick pipeline Here we specify a pipeline for 1. Getting a fortune 2. Echoing it 3. Using the fortune to make a limerick ``` fortune | tee /dev/tty | LLMChat --prompt="Make a limerick from the given text:" ``` ```text I have made this letter longer than usual because I lack the time to make it shorter. -- Blaise Pascal There once was a note, quite verbose, Longer than needed, I suppose. Pascal said with a grin, “To be short takes more spin,” So brevity’s craft he chose to oppose. ``` **Remark:** In the shell command above, `LLMChat` created (or reused) a chat object with the default identifier "NONE". ### Make a diagram from previous results Here we use prompt expansion to request the creation of a [Mermaid-JS diagram](https://mermaid.js.org) via the prompt ["CodeWriterX"](https://www.wolframcloud.com/obj/antononcube/DeployedResources/Prompt/CodeWriterX/): ``` LLMChatMeta last-message --i=NONE | LLMChat - --i=mmd --prompt='Make a mermaid.js sequence diagram #NothingElse|"mermaid.js code"' ``` ```` ```mermaid sequenceDiagram participant Blaise as Blaise Pascal participant Note as Note participant Reader as Reader Blaise->>Note: Write verbose letter Note->>Reader: Deliver longer-than-usual message Blaise->>Reader: "To be short takes more spin" Note->>Reader: "Brevity's craft opposed" ``` ```` Since the result is given in Markdown code fences we take the last message via the CLI script `LLMMetaChat`, then use `sed` to remove the first and last lines, and then pass that text to the terminal Mermaid-JS visualizer [`mmdflux`](https://github.com/kevinswiber/mmdflux): ``` LLMChatMeta last-message --i=mmd | sed '1d; $d' | mmdflux ``` ```text ┌───────────────┐ ┌──────┐ ┌────────┐ │ Blaise Pascal │ │ Note │ │ Reader │ └───────┬───────┘ └───┬──┘ └────┬───┘ │ │ │ │─Write verbose letter──────────────>│ │ │ │ │ │ │─Deliver longer-than-usual message─>│ │ │ │ │─"To be short takes more spin"──────────────────────────────────────────>│ │ │ │ │ │─"Brevity's craft opposed"─────────>│ │ │ │ ``` **Remark:** Since the result is usually given in Markdown code fences, we did not make a pipeline to plot the diagram. We used two shell commands in order to observe the intermediate result. **Remark:** The default object identifier for both `LLMChat` and `LLMChatMeta` is "NONE". ### Copy-editing Here is a very practical example -- this document was copy-edited with the prompt ["CopyEdit"](https://resources.wolframcloud.com/PromptRepository/resources/CopyEdit) using the following commands: ``` cat Chatnik-LLM-Host-in-the-Shell-Part-1.md | LLMChat - --i=ce --prompt=@CopyEdit --model=gpt-5.4-mini --max-tokens=16384 LLMChatMeta last-message --i=ce > Chatnik-LLM-Host-in-the-Shell-Part-1_edited.md open Chatnik-LLM-Host-in-the-Shell-Part-1_edited.md ``` (And, yes, the LLM copy-edited version was evaluated, and some edits were rejected.) --- ## Why make another LLM-CLI system? ### Some questions to answer * Why do it? * Why was it relatively easy to do? * Why is it useful? ### Why do it? Most LLM interfaces -- both "big" popular ones and those built by developers experimenting with LLMs -- default to an application-centric design: a closed interaction loop with implicit state. This pattern is convenient, but very limiting. It can be cynically seen as an intentional effort for user lock-in or just as an attempt to impose certain user-experience views. It works against the "freedom enabling" Unix design principles. (Such as composability, transparency, and scriptability.) With "Chatnik", instead of adapting workflows to fit an LLM application, LLM capabilities are brought into the shell as first-class primitives. This enables reuse of existing tooling (pipes, redirects, scripts) and aligns LLM interaction with long-established UNIX practices. ### Why was it relatively easy to do? "Chatnik" is a composition of existing capabilities rather than a ground-up implementation: * Modern LLM providers (e.g., OpenAI, Google, Ollama) expose messy, non-uniform APIs that should be abstracted behind a single interface * The Raku ecosystem already provides flexible text processing, DSL making and usage, and CLI tooling * The "LLM::Functions" package encapsulates model interaction patterns, reducing knowledge of concrete APIs * Persistence can be implemented with simple file-based storage, avoiding the need for complex infrastructure **Remark:** Related to the last point above, the following quote is attributed to [Ken Thompson](https://en.wikiquote.org/wiki/Ken_Thompson) about UNIX: > We have persistent objects, they're called files. **Remark:** Less obnoxiously, instead of saying that LLM providers expose messy, non-uniform APIs, we can say that their APIs "are individually reasonable, but collectively inconsistent." Because of the popularity of OpenAI's models, many LLM providers adhere to a degree with OpenAI's API. Still, the APIs -- collectively -- have inconsistent schemas, authorization, streaming, tool-calling, roles, etc. ### Why is it useful? "Chatnik" is useful because it places LLM capabilities in a natural manner into Unix shell workflows: * LLM calls can be embedded into shell pipelines, enabling automation and chaining * Conversations are persistent and inspectable via the file system * Prompt reuse and DSL preprocessing reduce repetition and keep workflows clear * Multiple providers can be used interchangeably without changing workflows * Existing UNIX tools (e.g., `grep`, `awk`, `sed`) can be combined with LLM outputs * Also, additional "widgets", like Markdown viewers, Mermaid-JS renderers, etc. ---- ## Architectural design The following flowchart summarizes the computational components and their interactions fairly well: [![enter image description here][2]](https://raw.githubusercontent.com/antononcube/MathematicaForPrediction/refs/heads/master/MarkdownDocuments/Diagrams/Chatnik-LLM-Host-in-the-Shell-Part-1/Chatnik-WL-flowchart-LR-light.png) Here is a concise narration of the flow: - A chat command is issued from the OS shell, triggering ingestion of the chat objects file into an in-memory chat database. - If a chat ID is specified and exists, the corresponding chat object is retrieved; otherwise, a new chat object is created (with a default “NONE” ID if unspecified). - The input is then processed through prompt parsing using a DSL. If known prompts are detected, they are expanded via the prompt repository; otherwise, the raw input proceeds directly. - The resulting message is evaluated through "LLM::Functions", which mediates interaction with external providers such as OpenAI (ChatGPT), Google (Gemini), and Ollama. - The evaluation produces a chat result returned to the shell, while the updated chat state is written back to the chat objects file, ensuring persistence. ### Expanded narration **Chatnik is built around the principle that LLM interaction should behave like a native shell capability, not a siloed application.** A command issued in the OS shell is treated as the entry point into a composable pipeline, where LLM calls can participate alongside standard UNIX tools. **State is externalized and file-backed, not hidden in process memory.** Chat sessions are represented as chat objects that are ingested from and persisted to the file system. This makes conversations durable, inspectable, and naturally versionable using existing OS tools. **Chat identity is explicit but optional.** When a chat ID is provided, the corresponding conversation is resumed; when absent or unknown, a new chat object is created. This allows both ad-hoc interactions and long-lived conversational contexts without friction. **Prompting is treated as a programmable layer.** Inputs are not passed directly to models; they are first parsed through a lightweight DSL. Known prompts are expanded from a prompt repository, enabling reuse, parameterization, and standardization of interactions. **LLM invocation is abstracted but not obscured.** Evaluation is delegated to "LLM::Functions", which provides a uniform interface over multiple providers, including OpenAI (ChatGPT), Google (Gemini), and Ollama. This keeps provider choice flexible while preserving a consistent workflow. **The system is designed for composability and integration.** Each stage—state ingestion, prompt processing, evaluation, and persistence—can be understood as part of a pipeline. This makes LLM interactions scriptable, chainable, and interoperable with existing command-line utilities. **Persistence is a first-class outcome of every interaction.** Every evaluation both returns a result to the shell and updates the underlying chat object store, ensuring that conversational context evolves incrementally and reliably. **In short.** To reiterate the point in the introduction, "Chatnik" treats LLMs as *shell-native, stateful, and programmable primitives* -- aligning conversational AI with the philosophy of UNIX pipelines rather than application-bound interfaces. ----- ## Related functions and packages In this section, we point to Raku packages that are both ingredients of, and alternatives to, "Chatnik". ### Main ingredients The LLM-chat object functionalities (creation and interaction) are provided by the Wolfram Language functions [`LLMConfiguration`](https://reference.wolfram.com/language/ref/LLMConfiguration.html), \[WRIf1\], [`LLMPrompt`](https://raku.land/zef:antononcube/LLM::Functions), \[WRIf2\], and [`LLMSynthesize`](https://reference.wolfram.com/language/ref/LLMSynthesize.html), \[WRIf3\]. In addition, the expansion of the [prompt DSL](https://writings.stephenwolfram.com/2023/06/introducing-chat-notebooks-integrating-llms-into-the-notebook-paradigm/#applying-functions-in-a-chat-notebook), \[SW1\], is done by the function [`ChatnikPromptExpand`](https://resources.wolframcloud.com/PacletRepository/resources/AntonAntonov/Chatnik/ref/ChatnikPromptExpand.html). The CLI script `LLMPrompt` of "Chatnik" can be used to examine, retrieve, and concretize prompts. For example, here it can be seen the full text of the function prompt "MermaidDiagram" with given arguments: ``` LLMPrompt MermaidDiagram MYTEXT MY_DIAGRAM_TYPE ``` In some cases it is more convenient to use `LLMPrompt` than prompt expansion. For example: ``` LLMChat "FOCUS TEXT START :: $(cat README.md) :: FOCUS TEXT END" | LLMChat - --i=fb --prompt="$(LLMPrompt ThinkingHatsFeedback 'FOCUS TEXT')" ``` Here is the context (prompt) of the chat object "fb": ``` LLMChatMeta context --i=fb ``` We can see the outcome of the `LLMChat` pipeline above with: ``` LLMChatMeta last-message --i=fb | cat > chat.md ``` ### Parsing of CLI arguments The paclet ["CommandLineParser"](https://resources.wolframcloud.com/PacletRepository/resources/Wolfram/CommandLineParser/), [MSp1], is used to parse the CLI arguments of the "Chatnik" scripts. The parser has certain limitations: - The non-named CLI arguments must be placed before the named ones. - The named arguments allways start with `--`. (I.e. `-i` does not work, `--i` does.) Because [`$ScriptInputString` is not very reliable](https://mathematica.stackexchange.com/q/204021) the positional argument `-` can be used to specify that the pipeline value as the input to `LLMChat`. ### Including `wolframscript` Of course, we can utilize "full power" of `wolframscript` (or WL) by making pipelines that combine LLM generations with WL computations. For example, here we get LLM-retrieved statistics and plot them (using the last message of the chat with "beta" above): ``` LLMChatMeta last-message --i=beta | sed '1d; $d' | wolframscript -code 'gr=ImportString[Import["!cat", "String"],"RawJSON"]//ReverseSort//ListPlot[#, ImageSize->600, PlotTheme -> "Detailed", PlotRange->All]&; Export["./beta.png", gr]' && open ./beta.png ``` <img src="https://raw.githubusercontent.com/antononcube/MathematicaForPrediction/refs/heads/master/MarkdownDocuments/Diagrams/Chatnik-LLM-Host-in-the-Shell-Part-1/beta.png" width="400" height="248" alt="Example Image"> ---- ## References ### Articles, blog posts \[AA1\] Anton Antonov, ["Jupyter::Chatbook"](https://rakuforprediction.wordpress.com/2023/09/03/jupyterchatbook), (2023), [RakuForPrediction at WordPress](https://rakuforprediction.wordpress.com). \[AA2\] Anton Antonov, ["Jupyter::Chatbook Cheatsheet"](https://rakuforprediction.wordpress.com/2026/03/14/jupyterchatbook-cheatsheet), (2026), [RakuForPrediction at WordPress](https://rakuforprediction.wordpress.com). \[AA3\] Anton Antonov, ["Jupyter Chatbook Cheatsheet"](https://pythonforprediction.wordpress.com/2026/03/12/jupyter-chatbook-cheatsheet), (2026), [PythonForPrediction at WordPress](https://rakuforprediction.wordpress.com). \[AA4\] Anton Antonov, ["Chatnik: LLM Host in the Shell — Part 1: First Examples & Design Principles"](https://rakuforprediction.wordpress.com/2026/04/25/chatnik-llm-host-in-the-shell-part-1-first-examples-design-principles/), (2026), [RakuForPrediction at WordPress](https://rakuforprediction.wordpress.com). \[AA5\] Anton Antonov, ["Chatnik: LLM Host in the Shell — Part 1: First Examples & Design Principles"](https://pythonforprediction.wordpress.com/2026/05/04/chatnik-llm-host-in-the-shell-part-1-first-examples-design-principles/), (2026), [PythonForPrediction at WordPress](https://pythonforprediction.wordpress.com). \[SW1\] Stephen Wolfram, ["Introducing Chat Notebooks: Integrating LLMs into the Notebook Paradigm"](https://writings.stephenwolfram.com/2023/06/introducing-chat-notebooks-integrating-llms-into-the-notebook-paradigm), (2023), [Stephen Wolfram Writings](https://writings.stephenwolfram.com). ### Functions \[WRIf1\] Wolfram Research, Inc., [LLMConfiguration](https://reference.wolfram.com/language/ref/LLMConfiguration.html), (2023), [Wolfram Language function](https://reference.wolfram.com/language/), (updated 2025). \[WRIf2\] Wolfram Research, Inc., [LLMPrompt](https://reference.wolfram.com/language/ref/LLMPrompt.html), (2023), [Wolfram Language function](https://reference.wolfram.com/language/). \[WRIf3\] Wolfram Research, Inc., [LLMSynthesize](https://reference.wolfram.com/language/ref/LLMSynthesize.html), (2023), [Wolfram Language function](https://reference.wolfram.com/language/), (updated 2025). ### Packages #### Python \[AAp1\] Anton Antonov, [LLMFunctionObjects, Python package](https://github.com/antononcube/Python-packages/tree/main/LLMFunctionObjects), (2023-2026), [GitHub/antononcube](https://github.com/antononcube). ([PyPI.org page](https://pypi.org/project/LLMFunctionObjects).) \[AAp2\] Anton Antonov, [LLMPrompts, Python package](https://github.com/antononcube/Python-packages/tree/main/LLMPrompts), (2023-2025), [GitHub/antononcube](https://github.com/antononcube). ([PyPI.org page](https://pypi.org/project/LLMPrompts).) \[AAp3\] Anton Antonov, [JupyterChatbook, Python package](https://github.com/antononcube/Python-JupyterChatbook), (2023-2026), [GitHub/antononcube](https://github.com/antononcube). ([PyPI.org page](https://pypi.org/project/JupyterChatbook).) \[AAp4\] Anton Antonov, [Chatnik, Python package](https://github.com/antononcube/Python-Chatnik), (2026), [GitHub/antononcube](https://github.com/antononcube). #### Raku \[AAp5\] Anton Antonov, [LLM::Functions, Raku package](https://github.com/antononcube/Raku-LLM-Functions), (2023-2026), [GitHub/antononcube](https://github.com/antononcube). \[AAp6\] Anton Antonov, [LLM::Prompts, Raku package](https://github.com/antononcube/Raku-LLM-Prompts), (2023-2025), [GitHub/antononcube](https://github.com/antononcube). \[AAp7\] Anton Antonov, [Jupyter::Chatbook, Raku package](https://github.com/antononcube/Raku-Jupyter-Chatbook), (2023-2026), [GitHub/antononcube](https://github.com/antononcube). \[AAp8\] Anton Antonov, [Chatnik, Raku package](https://github.com/antononcube/Raku-Chatnik), (2026), [GitHub/antononcube](https://github.com/antononcube). #### Wolfram Language \[AAp9\] Anton Antonov, [Chatnik, Wolfram Language paclet](https://resources.wolframcloud.com/PacletRepository/resources/AntonAntonov/Chatnik/), (2026), [Wolfram Language Paclet Repository](https://resources.wolframcloud.com/PacletRepository). \[MSp1\] Matteo Salvarezza, [CommandLineParser, Wolfram Language paclet](https://resources.wolframcloud.com/PacletRepository/resources/Wolfram/CommandLineParser/), (2024), [Wolfram Language Paclet Repository](https://resources.wolframcloud.com/PacletRepository). \[CGp1\] Connor Gray, et al., [Chatbook, Wolfram Language paclet](https://resources.wolframcloud.com/PacletRepository/resources/Wolfram/Chatbook), (2023-2024), [Wolfram Language Paclet Repository](https://resources.wolframcloud.com/PacletRepository). ### Videos \[AAv1\] Anton Antonov, ["Integrating Large Language Models with Raku"](https://youtu.be/-OxKqRrQvh0?si=5LEj8-Dtcxjn-0QR&t=548), (2023), [The Raku Conference 2023 at YouTube](https://www.youtube.com/@therakuconference6823). [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=Chatnik-Androids-shelf-11-conveyor-clean-lab-WL-styled-small.png&userId=143837 [2]: https://community.wolfram.com//c/portal/getImageAttachment?filename=Chatnik-WL-flowchart-LR-light.png&userId=143837 [3]: https://community.wolfram.com//c/portal/getImageAttachment?filename=beta.png&userId=143837 Anton Antonov 2026-05-16T09:57:01Z https://community.wolfram.com/groups/-/m/t/3716185 ![Aliens? Or weather balloons? You decide!][1] &[Wolfram Notebook][2] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=AliensOrWeatherBalloonsYouDecide.jpg&userId=20103 [2]: https://www.wolframcloud.com/obj/a9f85d83-9d1a-47dc-92bc-bf3cfa1232c4 Arnoud Buzing 2026-05-15T00:20:07Z https://community.wolfram.com/groups/-/m/t/3714434 &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/29993871-3320-4b92-ad43-c1f5f15e7f4c Housam Binous 2026-05-11T15:40:29Z https://community.wolfram.com/groups/-/m/t/3713149 &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/ecebb253-25b4-4425-be27-e7938c118e58 Marco Thiel 2026-05-07T20:36:56Z https://community.wolfram.com/groups/-/m/t/3713168 &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/d8cb36aa-2087-48bf-ab2a-41596e9d07c6 Marco Thiel 2026-05-08T09:06:26Z https://community.wolfram.com/groups/-/m/t/2437685 I'm very happy with the continued improvement of the Dicom import and export functionality and speed. However, there is one issue with the current implementation that makes it very unuseful if you do quantitative image analysis. It might be that I miss an option if not I think this should be fixed. In the Mathematica documentation and examples, Dicom data is typically shown and imported as images which I understand for display purposes. But I consider the information in Dicom files as data, very well curated and standardized. For many (MRI) applications, the actual quantitative values of voxels stored in Dicom actually have meaning, values, and even units. For example in the image below each voxel value is actually a quantitative measure of T2 relaxation time in the heart, where the values are stored in milliseconds as voxel values as is also mentioned in the metadata. ![enter image description here][1] ![enter image description here][2] To get from the stored values to quantitative values (WV, DV or FP) the fields from the header and the equations are well defined. Header values: - SV = stored value of DICOM PIXEL DATA without scaling - WS = RealWorldValue slope (0040,9225) "RWVSlope" - WI = RealWorldValue intercept (0040,9224) "RWVIntercept" - RS = rescale slope (0028,1053) "RescaleSlope" - RI = rescale intercept (0028,1052) "RescaleIntercept" - SS = scale slope (2005,100E) "ScaleSlope" Outputs: - WV = real world value - FP = precise value - DV = displayed value Formulas: - WV = SV * WS + WI - DV = SV * RS + RI - FP = DV / (RS * SS) So my first try was that I want to obtain the "RawData" to access the SV pixel data, which does not output anything. ![enter image description here][3] Eventually, if I import this Dicom file into Mathematica I have to use a lot of tricks to get to the correct stored values. The Dicom images I use are stored as 12-bit Integers but are converted by Mathematica to a Numerical array with type Int16. Also, I have to specifically specify that I don't want any "DataTransformation" which by default rescales the data and actually changes some voxel values!!!! In[1]:= << QMRITools` {meta, data, bd} = Import[file, {"dicom", {"MetaInformation", "Data", "BitDepth"}}, "DataTransformation" -> None]; dataT = Import[file, {"dicom", {"Data"}}]; {dd = ToExpression[ StringJoin @@ StringCases[NumericArrayType[data], DigitCharacter]], bd} {ss, rs, ri} = meta /@ {"2005_100e", "RescaleSlope", "RescaleIntercept"} {data, dataT} = Normal@{data, dataT}; svT = 2.^bd (dataT/(2.^dd)); pfT = (rs svT + ri)/(rs ss); sv = 2.^bd (data/(2.^dd)); pf = (rs sv + ri)/(rs ss); PlotData[pfT, pf] Out[3]= {16, 12} Out[4]= {1.99854, 0.500366, -2.} For my current research, I need the PF values and to get them correctly I have to: 1. Use "DataTransformation"->None, which is not really well documented what it actually does. But based on what I see actual values of the data are changed by clipping the histogram, which for default handling of medical data is never OK!! ![enter image description here][4] 2. As far as I am aware the only way to obtain the actual stored values of my Dicom data (the actual binary values stored in the file itself) I have to find the actual BiteDepth and the imported data type and rescale my data accordingly. Below are the obtained PF valued data I need with and without DataTransformation. Although the image on the right might look less appealing with default range and scaling it is actually correct when scaled apropriately. ![enter image description here][5] ![enter image description here][6] Am I missing a correct option for getting the actual data stored? If not this should definitely be changed. Dicom is the international standard to transmit, store, retrieve, print, process, and display medical imaging information. With the current implementation, it is impossible to Import and Export such files without actually changing the stored data. Thanks, Martijn [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=dcmtag.png&userId=1332602 [2]: https://community.wolfram.com//c/portal/getImageAttachment?filename=T2map.png&userId=1332602 [3]: https://community.wolfram.com//c/portal/getImageAttachment?filename=raw.png&userId=1332602 [4]: https://community.wolfram.com//c/portal/getImageAttachment?filename=hist.png&userId=1332602 [5]: https://community.wolfram.com//c/portal/getImageAttachment?filename=dataTrans1.png&userId=1332602 [6]: https://community.wolfram.com//c/portal/getImageAttachment?filename=dataTrans2.png&userId=1332602 Martijn Froeling 2022-01-05T09:42:43Z https://community.wolfram.com/groups/-/m/t/3706203 &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/1ad1af94-9785-4367-b665-21c66f5a4045 Lim Lee 2026-04-27T04:06:18Z https://community.wolfram.com/groups/-/m/t/3711906 Maybe the theorem has a set of measure 0 for which it fails? I have 3 nested functions, each quadratic in its inputs. A standard multi-layer linear plus logistic NN with ADAM optimizer can't seem to minimize the loss (or it gets stuck in a local minimum). I've tried varying the number of layers, and their width, but to no avail. What's going on? &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/47d5251d-896e-4401-97eb-d9794b91e871 Iuval Clejan 2026-05-04T19:31:25Z https://community.wolfram.com/groups/-/m/t/3711368 &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/5c8debc6-a7fd-4b2d-a23b-37a07d81fe5c Jayanta Phadikar 2026-05-04T16:02:13Z https://community.wolfram.com/groups/-/m/t/3710670 &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/d67fd36a-d01f-41e6-bcc2-939ceed7aed9 Marco Thiel 2026-05-03T19:10:32Z https://community.wolfram.com/groups/-/m/t/3709700 ![Quantitative analysis of the semiconductor-electrolyte interface using cyclic voltammetry measurements][1] &[Wolfram Notebook][2] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=images_large_ja5c18135_0009.jpeg&userId=20103 [2]: https://www.wolframcloud.com/obj/07aae052-ea75-4d33-983c-0b3a4f6a35f9 Renato Neiva Sampaio 2026-04-30T16:33:27Z https://community.wolfram.com/groups/-/m/t/3680280 Built this over few weekends, an MCP server that connects AI agents (Claude, Codex etc) directly to your local Mathematica. It lets the agent run Wolfram Language code, manipulate frontend notebooks, export plots, and query Wolfram Alpha(82 tools total). You don't even need to know every Mathematica command, as the agent can look up functions and documentation on its own. Watch it in action: https://youtu.be/TjGSkvVyc1Y **Would love for people in this community to give it a try. Your feedback would help me keep improving it.** [](https://www.youtube.com/watch?v=TjGSkvVyc1Y) --- *An AI agent solving math, generating plots, and controlling a live Mathematica notebook. Errors are returned directly to the agent, no copy-pasting notebook output back into chat.* --- ## Documentation * **[GitHub Repository](https://github.com/AbhiRawat4841/mathematica-mcp)**: All files and documentations * **[Technical Reference](https://github.com/AbhiRawat4841/mathematica-mcp/blob/main/docs/technical-reference.md)**: Architecture, tools, and configuration * **[Security Model](https://github.com/AbhiRawat4841/mathematica-mcp/blob/main/SECURITY.md)**: Threat model, permissions, and vulnerability reporting * **[Benchmarks](https://github.com/AbhiRawat4841/mathematica-mcp/blob/main/docs/benchmarks.md)**: Performance data and reproduction steps * **[Contributing](https://github.com/AbhiRawat4841/mathematica-mcp/blob/main/CONTRIBUTING.md)**: Development setup, testing, and PR process * **[Changelog](https://github.com/AbhiRawat4841/mathematica-mcp/blob/main/CHANGELOG.md)**: Version history * **[Examples](https://github.com/AbhiRawat4841/mathematica-mcp/tree/main/docs/examples)**: Polished agent session walkthroughs ## Why This Exists LLMs can write Mathematica code, but they can't run it, verify it, or interact with live notebooks. This MCP server bridges that gap: - **Live notebook control**: create, edit, evaluate, and screenshot Mathematica notebooks directly from your AI agent - **Symbolic + numeric + visual in one MCP**: ~82 tools covering algebra, calculus, plotting, data import/export, Wolfram Alpha, and interactive UIs - **Agent-optimized**: compact response shaping, session state tools, and computation journaling designed for how LLM agents actually work - **Error-aware execution**: Mathematica errors and warnings are returned directly to the agent, so it can debug without you manually copying notebook output back into chat - **Local and private**: core execution runs on your machine — optional tools like `wolfram_alpha` and repository search contact Wolfram's cloud services when invoked > Ask your agent for a derivation, a 3D plot, a notebook edit, or a verification step, and it can actually do it. --- ## Who This Is For ![enter image description here][2] --- ## What You Can Ask For **"Integrate x^2 sin(x) from 0 to pi, then verify the result."** ```text execute_code("Integrate[x^2 Sin[x], {x, 0, Pi}]") => -4 + Pi^2 verify_derivation(steps=["Integrate[...", "-4 + Pi^2"]) => All steps valid ``` **"Plot the sombrero function in a new notebook."** ```text create_notebook(title="Sombrero") execute_code("Plot3D[Sinc[Sqrt[x^2+y^2]], {x,-4,4}, {y,-4,4}]", style="notebook") => [3D surface plot rendered in live notebook] ``` **"Interactive: slider for Sin[n x]"** ```text execute_code("Manipulate[Plot[Sin[n x],{x,0,2Pi}],{n,1,10}]", style="interactive") => [Live slider UI in Mathematica frontend] ``` Beyond these: **data import/export** (hundreds of formats), **Wolfram Alpha queries**, **notebook reading/analysis**, **symbolic debugging**, and more. See the [Technical Reference](docs/technical-reference.md) for the full tool list. --- ## How It Compares ![enter image description here][3] \*Core computation runs locally. Optional tools (`wolfram_alpha`, repository search) contact Wolfram cloud services when invoked. --- ## Quick Start From install to first working notebook plot in under 2 minutes. ### Prerequisites 1- **Mathematica 14.0+** with `wolframscript` in your PATH - [Download Mathematica](https://www.wolfram.com/mathematica/) - macOS: Add to `~/.zshrc`: `export PATH="/Applications/Mathematica.app/Contents/MacOS:$PATH"` 2- **uv package manager** curl -LsSf https://astral.sh/uv/install.sh | sh ### One-Command Setup ```bash # For Claude Desktop uvx mathematica-mcp-full setup claude-desktop # For Cursor uvx mathematica-mcp-full setup cursor # For VS Code (requires GitHub Copilot Chat extension) uvx mathematica-mcp-full setup vscode # For OpenAI Codex CLI uvx mathematica-mcp-full setup codex # For Google Gemini CLI uvx mathematica-mcp-full setup gemini # For Claude Code CLI uvx mathematica-mcp-full setup claude-code # Optional: select a tool profile (default is "full") uvx mathematica-mcp-full setup claude-desktop --profile notebook ``` Then restart Mathematica and your editor. Done! ####VS Code: Alternative setup via Command Palette > **Prerequisite:** [GitHub Copilot Chat](https://marketplace.visualstudio.com/items?itemName=GitHub.copilot-chat) extension must be installed - MCP support is built into Copilot. 1. Press `Cmd+Shift+P` (Mac) / `Ctrl+Shift+P` (Windows) 2. Type "MCP" -> Select **"MCP: Add Server"** 3. Choose **"Command (stdio)"**: *not "pip"* 4. Enter command: `uvx` 5. Enter args: `mathematica-mcp-full` 6. Name it: `mathematica` 7. Choose scope: Workspace or User ####Alternative: Interactive Installer ```bash bash <(curl -sSL https://raw.githubusercontent.com/AbhiRawat4841/mathematica-mcp/main/install.sh) ``` ### Verify Installation ```bash uvx mathematica-mcp-full doctor ``` > **Tip:** If you encounter errors after updating, clear the cache: > ```bash > uv cache clean mathematica-mcp-full && uvx mathematica-mcp-full setup <client> > ``` --- ## Execution Styles Control where results appear with natural language or the `style` parameter: ![enter image description here][4] If you don't include a keyword, the default depends on your [tool profile](#tool-profiles). --- ## Tool Profiles Choose how many tools to expose: ![enter image description here][5] Pass `--profile` during setup or set `MATHEMATICA_PROFILE` env var. --- ## Built for Agent Workflows The server is designed for how LLM agents actually work: long conversations with context limits, intermittent failures, and token budgets: ![enter image description here][6] Notebook execution is strict about the requested target: if notebook transport fails, the server returns a notebook error instead of silently rerunning the work through CLI fallback. ### Routing Intelligence (opt-in) For power users, the server can learn from transport outcomes and adapt: ```bash # Observe mode: collect stats, no behavior change export MATHEMATICA_ROUTING_MEMORY=observe # Advise mode: + routing hints + enables adaptive routing export MATHEMATICA_ROUTING_MEMORY=advise export MATHEMATICA_ROUTING_ACTION=compute_cli_skip # optional: skip failing transport ``` The adaptive routing circuit-breaker automatically skips persistently failing compute CLI transport with half-open probe recovery. See the [Technical Reference](docs/technical-reference.md#intelligent-routing--observability) for details. > **Privacy:** Routing memory stores only aggregate counters; the in-memory journal stores short code/output previews (not persisted). Notebook extraction results are cached to `~/.cache/mathematica-mcp/notebooks/` with mtime-based invalidation; delete the directory to clear the cache. --- ## Manual Installation For full details, troubleshooting, and advanced configuration, see the **[Installation Guide](docs/installation.md)**. ####Quick manual setup 1. **Clone & Install**: git clone https://github.com/AbhiRawat4841/mathematica-mcp.git cd mathematica-mcp uv sync 2. **Install Mathematica Addon**: wolframscript -file addon/install.wl *Restart Mathematica after this step.* 3. **Configure your editor**: add the MCP server to your client's config file. See the **[Installation Guide](docs/installation.md#step-4-configure-your-editor)** for Claude Desktop, Cursor, VS Code, and other client configs. --- ## License MIT License [1]: https://github.com/AbhiRawat4841/mathematica-mcp [2]: https://community.wolfram.com//c/portal/getImageAttachment?filename=Table1.jpg&userId=20103 [3]: https://community.wolfram.com//c/portal/getImageAttachment?filename=Table2.jpg&userId=20103 [4]: https://community.wolfram.com//c/portal/getImageAttachment?filename=Table3.jpg&userId=20103 [5]: https://community.wolfram.com//c/portal/getImageAttachment?filename=Table4.jpg&userId=20103 [6]: https://community.wolfram.com//c/portal/getImageAttachment?filename=Table5.jpg&userId=20103 Abhishek Singh Rawat 2026-04-10T00:05:40Z https://community.wolfram.com/groups/-/m/t/3707090 &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/6473f01c-b05e-47e9-b7e6-eb1be887dd10 Marco Thiel 2026-04-28T14:30:05Z https://community.wolfram.com/groups/-/m/t/3706053 &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/a49573e8-cea9-45c4-bb19-dcb97c545f0b Marco Thiel 2026-04-26T23:35:34Z https://community.wolfram.com/groups/-/m/t/3701280 ![Exploring NASA SkyView: live imagery, dark-nebula analysis, & catalogue-driven sky-survey downloader][1] &[Wolfram Notebook][2] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=ExploringNASASkyViewliveimagery.png&userId=20103 [2]: https://www.wolframcloud.com/obj/928898a9-67eb-4590-bdf7-0113b2c76db4 Marco Thiel 2026-04-22T22:27:38Z https://community.wolfram.com/groups/-/m/t/3699792 &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/0e8340b8-e38d-4ec0-934f-44ad1b750759 Dara Shayda 2026-04-21T23:09:32Z https://community.wolfram.com/groups/-/m/t/3699762 ![Anthropogenic influences on the water cycle amplify uncertainty in drought assessments][1] &[Wolfram Notebook][2] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=Anthropogenicinfluencesonthewatercycleamplifyuncertaintyindroughtassessments.jpg&userId=20103 [2]: https://www.wolframcloud.com/obj/64c0866f-7899-4f9e-ab67-009908bcaa6c Wanshu Nie 2026-04-21T19:41:15Z https://community.wolfram.com/groups/-/m/t/3694627 ![Animate the CNN fear and greed index gauge][1] &[Wolfram Notebook][2] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=2026-04-18_08-21-01%281%29.gif&userId=23928 [2]: https://www.wolframcloud.com/obj/78e1cc5e-337f-4db8-a96f-39e8aec8ce98 Shenghui Yang 2026-04-18T01:00:43Z https://community.wolfram.com/groups/-/m/t/3696836 [![Diffusion Cartograms: implementation of the Gastner—Newman density-equalising map algorithm][1]][2] &[Wolfram Notebook][3] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=DiffusionCartogramsimplementationoftheGastner%E2%80%94Newmandensity-equalisingmapalgorithm.png&userId=20103 [2]: https://community.wolfram.com//c/portal/getImageAttachment?filename=DiffusionCartogramsimplementationoftheGastner%E2%80%94Newmandensity-equalisingmapalgorithm.png&userId=20103 [3]: https://www.wolframcloud.com/obj/3a527987-4ff8-465d-a769-6bc59f8463bd Marco Thiel 2026-04-19T16:53:07Z https://community.wolfram.com/groups/-/m/t/3697119 ![Click-and-drag map projection distortion in The Wolfram Language][1] &[Wolfram Notebook][2] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=Click-and-dragMapProjectionDistortion-optimize.gif&userId=20103 [2]: https://www.wolframcloud.com/obj/7c2f9bae-74fd-477e-b892-234c09fd6243 Marco Thiel 2026-04-20T09:39:53Z