How I made a command line chatbot

Since the end of 2022, we have been inundated with LLM chatbots in our everyday lives. The typical use involves some sort of interface that we sign into, where our previous chats can be saved, and so forth. At some point early on, these chatbots were available via API. Here, I want to show how I made a chatbot that can be called from the command line anywhere on my computer.

The use case I'll show you is that of the literate programming environment, which in turn allows you to basically have and store platonic dialogues that are in turn saved and stored. This helps me with specific use cases, like getting feedback on journal entries and notes in real time. A specific example of this involves my German learning, where I often use LLMs to be a conversational partner that provides feedback in real time. Otherwise, in my line of work, I do a lot of research, so I often use LLMs to bounce ideas off of, and so forth. A literate programming environment helps save this feedback directly into the notes I'm taking.

In short, having LLMs available on the command line is useful, and here, I'm going to show you how I do it. The punchline is that it is not particularly hard to do.

Now that we are able to call chatbot and searchbot from the command line, we now have to talk about what is possible that otherwise cannot be done in the LLM UI/UX. Here is where knowing how to code (as opposed to knowing how to prompt LLMs to code) really comes in handy. Because to understand the next level of prompt engineering, you need to be able to think algorithmically.

What we can do now is what I call prompt scripting. This is where you write scripts (in whatever programming language) where the data structures are LLM agents, rather than just strings and ints, for example. In order to help you understand what I'm talking about, I'm going to go right into a simple example.

Below, we are going to use searchbot and chatbot in a simple manner. We are going to produce a prompt for searchbot. We are then going to feed the searchbot results and the original prompt directly into chatbot, which will then produce a report.

source ~/.zshrc

# Architecture:
# Terminal goal: Produce a newsletter
# (user)--[prompt]-->(internet search agent)--[research notes]-->(reasoning agent)--> *newsletter*

# Setting the search prompt
search_prompt="Please give me the lastest news around LLM developments. Focus on things that have happened as of February 1, 2025 and after. Use the most reputable sources possible."

# Internet searching agent produces research notes
news=$(searchbot "$search_prompt")

# Setting the newsletter prompt
newsletter_prompt="You are to produce a newsletter given the latest updates around LLM developments as of February 1, 2025. A researcher, perplexity, has compiled notes for you to use. You will take these as input and produce the newsletter. Make it academic in style. Include citations as you would an academic journal, both in the report with footnotes along with a citations section. Begin with an abstract that summarizes these developments. The research notes you will use, along with sources, is here: $news"

# Reasoning agent produces the newsletter
newsletter=$(chatbot "deepseek" "$newsletter_prompt")

echo "$newsletter"

**Abstract**
The field of Large Language Models (LLMs) has witnessed significant advancements as of February 2025, marked by innovations in architecture, efficiency, and specialization. Highlights include DeepSeek R1, a cost-efficient open-source model excelling in mathematical and coding tasks; Rakuten AI 2.0, Japan’s first MoE-based bilingual model optimized for edge deployment; and Google’s Gemini 1.5, which features an unprecedented one million-token context window. Concurrently, Alibaba’s Qwen2.5-Max demonstrates superior benchmark performance, while LG AI Research’s EXAONE 3.0 advances multilingual and domain-specific applications. These developments reflect a broader trend toward scalability, accessibility, and task-specific optimization in LLM research[1][5][9].

---

**Key Developments in LLM Technology (2024–2025)**

**1. DeepSeek R1: Open-Source Efficiency with Narrowed Specialization**
Released in January 2025, DeepSeek R1 represents a breakthrough in parameter-efficient training. With 671 billion total parameters and 37 billion active parameters, it matches or exceeds OpenAI’s proprietary models in mathematical reasoning (GSM8K: 89.3%) and coding benchmarks (HumanEval: 84.7%)[1]. Notably, its training cost—reportedly 40% lower than comparable models—has driven adoption in academic and open-source communities[8]. The model’s selective parameter activation reduces inference latency, making it a viable option for resource-constrained environments[7].

**2. Rakuten AI 2.0: MoE Architecture for Japanese Language Processing**
Rakuten Group’s February 2025 release of Rakuten AI 2.0 introduces Japan’s first Mixture of Experts (MoE) LLM. The model employs eight distinct 7B-parameter experts, achieving performance parity with monolithic 70B models in Japanese NLP tasks[5]. A companion “mini” variant (2.8B parameters) targets edge-device applications, emphasizing low power consumption and sub-100ms latency. Early evaluations highlight its efficacy in customer service automation and real-time translation[5].

**3. Gemini 1.5: Context Window Expansion**
Google’s Gemini 1.5, announced in February 2024 but widely adopted by 2025, pioneers a one million-token context window—7x larger than previous iterations[1]. This allows single-prompt processing of 30,000 code lines or 700,000 words, enabling novel applications in long-form content analysis and cross-document inference. Early industry use cases include legal contract review and video transcript summarization[3][10].

**4. Qwen2.5-Max: Benchmark Dominance in Efficiency-Critical Tasks**
Alibaba’s Qwen2.5-Max, released in early 2025, outperforms competitors (including DeepSeek V3) in low-latency benchmarks such as LiveCodeBench (+12.4%) and GPQA-Diamond (+8.9%)[9]. While parameter counts remain undisclosed, its architecture employs dynamic sparse attention to reduce computational overhead. The model is now integrated into Alibaba Cloud’s enterprise API suite, targeting finance and healthcare sectors[7][9].

**5. EXAONE 3.0: Multilingual and Domain-Specific Advancements**
LG AI Research’s EXAONE 3.0 (December 2024) features 7.8B parameters optimized for chemistry, patent analysis, and bilingual (Korean-English) tasks[9]. Its instruction-tuned variant, released under a non-commercial license, has facilitated academic research in cross-lingual transfer learning. Notably, EXAONE 3.0 achieves state-of-the-art results in the KR-STEM benchmark (92.1 F1-score), aiding South Korea’s scientific R&D initiatives[9].

---

**Citations**
[1] Exploding Topics. (2025). *List of Leading LLMs*. https://explodingtopics.com/blog/list-of-llms
[3] Georgia Tech. (2025). *AI Trends: What’s Next for Large Language Models*. https://www.cc.gatech.edu/news/ai-ai-popular-large-language-models-weigh-whats-next-ai-2025
[5] Rakuten Group. (2025). *Press Release: Rakuten AI 2.0 Launch*. https://global.rakuten.com/corp/news/press/2025/0212_02.html
[7] Vamsi Talks Tech. (2025). *LLM Evolution: 2024–2025 Technical Review*. https://www.vamsitalkstech.com/ai/the-evolution-of-large-language-models-in-2024-and-where-we-are-headed-in-2025-a-technical-review/
[8] TechTarget. (2025). *DeepSeek: Technical Overview*. https://www.techtarget.com/whatis/feature/DeepSeek-explained-Everything-you-need-to-know
[9] Shakudo. (2025). *Top LLMs of 2025*. https://www.shakudo.io/blog/top-9-large-language-models
[10] Deloitte. (2025). *AI Agents and Autonomous Systems*. https://www2.deloitte.com/us/en/insights/focus/tech-trends/2025/tech-trends-ai-agents-and-autonomous-ai.html

---
*Format: Academic newsletter with numeric citations corresponding to sources. Footnotes integrated via bracketed numbers linked to the citations section.*

You get the picture. Here, I had the overall goal of making a newsletter. To this end, I set up an "agent" to do internet search and prepare research notes that would in turn be used by a reasoning model to turn it into an academic style newsletter. This is a very simple version of this, and I note that if you really read the output, it is informative but not perfect. Further improvements could be made on the prompt, or adding additional agents to do more research, edit the report, check for errors, and so forth. But I'll leave additional layers of complexity as an exercise to the reader.

I'd like to show you one more thing you can do when you start thinking in terms of prompt scripting. And that is adding a code execution layer to these prompts. Below is a simple script where a LLM produces code that is in turn executed. The user sees just the execution.

source ~/.zshrc

# Architecture:
# Terminal goal: execute code based on the user's natural language query
# (user)--[prompt]-->(code producing agent)--[code]-->(code executing agent)--> *code output*

# Make the code
cmd=$(chatbot "claude" "Please produce a shell command to give me today's date and time. Just produce the command. Do not produce anything else.")
echo "$cmd"

# Execute the code (rather than copy/paste)
eval "$cmd"

date
Sun Feb 16 10:05:20 CET 2025

In the case of shell scripting, you simply use the "eval" command to run any code passed into it as a string, which is what I can get the chatbot to do.

You can imagine that we could get the chatbot to produce much more complex commands for whichever language as part of a much more complex pipeline. Again, I'll leave that as an exercise to the reader, now that you have the toolkit to do so.

We will now move to the related topic of how to get these commands working in a literate programming environment.

Since I made this command line cool and figured how to use it in a literate programming context, it has increased my productivity especially in the contexts of my German learning (I am American living in Berlin), and my research work. The more general theme is that I write prolifically in my literate programming environment (Org-Mode), and now I can get direct feedback from LLMs directly within this environment.

In general, I write to think. Thus, now I can think and get real time feedback on my thoughts by LLMs that are becoming increasingly better, and are hallucinating less often. I have seen the occasional comment about how LLMs are going to reduce our ability to think about stuff, because we will end up outsourcing our cognition to them. My general goal is to use LLMs as a way to help me think more effectively about stuff, because being good a thinking about stuff is a core value of mine.

This is similar to bench pressing by myself versus with a spotter. As opposed to getting a spotter to do the bench pressing for me while I sit back and watch. That is a sort of litmus test for my LLM use: does it increase brain activity or decrease it? If my brain activity goes up or at least stays the same, then I will consider it a valid use case for me. If my brain activity goes down, then that is not a valid use case for me.

Adding the capability to have API access to internet-searching LLMs, which is what Bing Chat (aka Sydney) originally did, makes it possible to have even more complexity in your LLM use. The example I used was that of having an internet search agent act produce research notes on a topic and then to have a reasoning-based agent convert that into a newsletter. Given new tools like OpenAI's Deep Research out there, I know that all of this this might seem a bit like reinventing the wheel, but one of the things that I want to do is understand how these things work under the hood. And one way to understand how something works is to build it yourself.

Finally, the bigger picture here is that there is a level above prompt engineering that I'm calling prompt scripting, where you start to think less in terms of prompts to LLMs and rather in terms of flow charts where each nodes is a LLM that has a different function and pre-prompt, passing output into other LLMs as input. This can allow for much you to achieve much more complex goals than that of a simple prompt. I gave a simple example of a 2-agent prompt script that produces a newsletter, and another example of an agent that produces a shell command that then gets directly executed. Think of these are simplest legos, from which you can build all kinds of complex things, the way you can build Tetris from NAND gates.

In short, having a LLM in a literate programming environment has done me some good, and I hope it will do some of you some good too. Give this a shot if only for the exercise of knowing how to do it. It's nice to be independent of the interfaces, and it's a "gateway drug" into building your own apps.