A Novice's Experience with Ollama AI

MojoPad
1

Previous to my exposure to MojoPad, I had never heard of Ollama. I discovered that it is an intimidating rabbit hole for the novice to enter.

After visiting ollama.com, downloading the app for macOS, and navigating their “Quickstart” guide, I had to find the “Terminal” app on my Mac. That is a place that I fear to tread. But with some starts and jerks, I managed to ask it my first question, which was as follows:

I am very new to Ollama and also very new to MojoPad.app. MojoPad.app tells me that Ollama is somehow integrated into the app. How is that so? Does MojoPad know that I have installed Ollama on this computer and there is nothing else I need to do in MojoPad? Ollama just “works” there?

After some “thinking”, Ollama responded with a long running narrative on how this integration is supposed to work. This is Ollama’s response:

Here’s a thinking process to construct the answer:

  1. **Analyze the User’s Core Questions/Concerns:**
    * User is new to Ollama and MojoPad.app.
    * MojoPad claims Ollama is integrated. (How?)
    * Does MojoPad know that Ollama was installed? (How does it detect
    it?)
    * Is there nothing else they need to do in MojoPad? (Is setup
    automatic?)
    * Does Ollama just “work” magically?
  2. **Deconstruct the Relationship (Ollama $\rightarrow$ MojoPad):**
    * *What is Ollama?* It’s a tool/daemon that runs large language
    models locally on your computer (e.g., Llama 3, Mistral). It provides an
    API endpoint (usually `http://localhost:11434`) for other programs to
    communicate with the model without needing cloud services.
    * *What is MojoPad?* Based on the context, it’s a specific
    application that *uses* LLMs for its functionality (likely coding or text
    generation).
    * *The Connection:* For MojoPad to use Ollama, it needs two things:
    1. Ollama must be running in the background (the server/daemon
    must be active).
    2. MojoPad must be configured to point its API calls to Ollama’s
    specific local address (`localhost`).
  3. **Address the User’s Questions with Specific Explanations (Structuring
    the Answer):**
    * **A. “How is it integrated?” (The Technical Explanation):**
    * It’s not magic; it’s an *API call*.
    * MojoPad has code that sends HTTP requests (like asking a
    question) to Ollama’s local address.
    * Ollama receives the request, runs the model locally, and sends
    the text response back to MojoPad.
    * **B. “Does MojoPad know I have installed it?” (The Detection
    Mechanism):**
    * It usually doesn’t *detect* installation status; it just needs
    the *service* running.
    * When you first open the app, it likely checks if a server is
    available at `localhost:11434`. If not, it might prompt you to
    install/start Ollama manually.
    * *Crucial point:* The prerequisite is that the **Ollama service
    must be running in the background**.
    * **C. “Is there nothing else I need to do?” (The
    Setup/Troubleshooting):**
    * Yes, most of the *interaction* is seamless once set up.
    * However, they *do* need to ensure:
    1. Ollama is installed.
    2. Ollama is running in the background (often starts
    automatically after installation).
    3. They have pulled a model (`ollama pull `). If
    they haven’t pulled any models, the app won’t know *what* to run.
    * **D. “Will it just ‘work’?” (The Conclusion/Summary):**
    * Mostly yes, but always ensure the background service is
    running and a model is loaded.
  4. **Refine Tone and Structure:**
    * Use encouraging and non-technical language initially, then dive
    into simple technical details.
    * Use bullet points for clarity.
    * Provide a clear “Action Items” list at the end to make the advice
    actionable. (This is key for a new user).
  5. **Review against constraints:** (Self-Correction: Ensure I am not
    claiming knowledge of future models or external tools beyond the
    explanation.) The answer is conceptual and focused on general AI
    integration principles, which is safe. (The plan looks solid.)
    …done thinking.
    This is an excellent question because it touches on a concept that often
    feels like “magic” when you are first starting out with local AI tools.
    When software integrations seem seamless, but the underlying technology is
    complex, it’s easy to feel confused about how they talk to each other.
    Here is a detailed breakdown of how this integration works, what MojoPad
    is doing, and exactly what you need to do (or ensure) for everything to
    work.

:brain: How Ollama Integrates into MojoPad (The “How”)

When software companies say that Program A is “integrated” with Tool B, it
almost never means they are wired together physically. It means that
**Program A knows how to speak the language of Tool B.**
In this case:

  1. **Ollama’s Role:** Ollama is not just a program; when you install it,
    it starts a **local server** (a background service or daemon) on your
    computer. This server constantly waits for requests and handles the heavy
    lifting of running complex models (like Llama 3). It exposes itself via an
    **API endpoint**, which is essentially a specific local web address
    (usually something like `http://localhost:11434`).
  2. **MojoPad’s Role:** MojoPad has been coded by its developers to know
    this exact API address and format. When you ask MojoPad to “generate code”
    or “answer this question,” the app doesn’t run the model itself. Instead,
    it packages your request into a structured message (an HTTP request) and
    sends that message over the internet connection (even though it’s only
    *local* traffic) directly to the Ollama server running on your machine.
  3. **The Process:**
    * *You type:* “Write a Python function.” $\rightarrow$ **MojoPad**
    captures this text.
    * **MojoPad sends:** The request to `localhost:11434`.
    * **Ollama receives:** It picks up the request, loads the specified
    model (e.g., Llama 3), runs the computation locally using your computer’s
    resources, and generates an answer.
    * **Ollama responds:** It sends the resulting text back to
    `localhost:11434`.
    * **MojoPad displays:** MojoPad captures the response data and shows
    it to you as if it had generated the content itself.
    ***The key takeaway: Ollama is running in the background, acting like a
    powerful engine that MojoPad drives.***

:magnifying_glass_tilted_right: Does MojoPad “Know” You Installed It? (The Detection)

No, not exactly. MojoPad doesn’t magically check your computer for an
installer file and say, “Oh, they installed it.”
What is more accurate is that: **MojoPad expects a functional API service
at a specific location.**
When you first open the app, one of two things must happen for it to work
seamlessly:

  1. **The Connection Test:** MojoPad likely tries to ping or connect to
    `localhost:11434`. If nothing is running there, the app will give you an
    error message or a setup prompt telling you that a local LLM server is
    required and pointing you toward Ollama.
  2. **Prerequisite Setup:** The developers of MojoPad have built their
    application around the assumption that if you are using it, you *have*
    installed Ollama first.
    If you followed the initial setup instructions (installing Ollama) and
    kept the Ollama service running in the background, then yes, everything
    should just “work.”

:white_check_mark: Does Everything Just “Work”? (The Necessary Steps)

While the interaction feels like a magic button press, there are **three
absolute prerequisites** that must be met for it to work:

1. The Service Must Be Running

Ollama cannot answer questions if its background service is shut down or
needs restarting. You must ensure the core Ollama daemon is active and
running in your system tray or background processes.

2. Models Must Be Downloaded (The “Brain”)

When you install Ollama, you only get the *engine*. To actually generate
text, you need to download a specific model (the actual weights of the
AI). If you haven’t pulled a model yet, MojoPad will send a request to an
engine that doesn’t know what language to speak.
**Example:** You must run `ollama pull llama3` in your terminal at least
once before MojoPad can use it. This downloads the “brain” into the local
Ollama system.

3. The API Key/Configuration Must Be Correct

MojoPad needs to be configured to point its requests to the correct
address (usually the default `localhost:11434`). Since this is an
application you are using and haven’t modified, we assume MojoPad has
handled this for you.
***

:rocket: Summary: Your Checklist for Success

Concept What it means Action Item for You
**Ollama** The local server (the “engine”). Keep the Ollama
application running in your background processes/system tray.
**Model Pulling** Downloading the actual AI brain (e.g., Llama 3).
Open your terminal and run `ollama pull ` (e.g., `llama3`).
**MojoPad Integration** The app’s coded way of sending a request to
Ollama’s server. If the setup was successful, you literally do nothing;
just type!

I then copied this response into a new page in a MojoPad document. Per instructions in the MojoPad Manual, I selected the pasted-in Ollama response, found the little buttons to edit with AI and selected “summarize”. After a short time, MojoPad (Ollama) responded with this:

  • Integration Mechanism: MojoPad communicates with Ollama by sending structured HTTP requests to Ollama’s local API endpoint (localhost:11434), rather than being physically wired together.

  • Process Flow: The user input is captured by MojoPad, sent to the running Ollama server, which processes it using a locally loaded model and returns the result for MojoPad to display.

  • Prerequisites for Success: For the system to work, three things must be true: 1) The Ollama background service must be actively running; 2) A specific AI model (e.g., Llama 3) must be downloaded using ollama pull; and 3) MojoPad must be correctly configured to point to the local API address.

Bottom Line — it may be worthwhile to add an Appendix to the MojoPad Manual that explains to novices how to actually get started with Ollama and other AI tools in simple procedural steps.

2

Thanks for posting this feedback.

I am going to automate 90% of the getting started with Ollama, in addition I am going to write up a detailed section in the documentation, and post that same content as a pinned message here. Sorry you had to go through all that trouble. In the future if you are about to start something you are unsure about or want help, or have a question, please post it here. I monitor this forum many times daily.

Mark

3

Thank you for this — it did more than you were asking for.

You suggested an appendix explaining how to get started with Ollama. Reading your post, the honest conclusion was that if the steps need writing down that carefully, MojoPad should be doing them. So in 1.59.0 it does.

Reach for any ✦ command with no model installed and MojoPad offers to set the whole thing up. It tells apart Ollama not being installed from Ollama being installed but asleep — it used to give the same advice for both, which meant telling people to install something already sitting in their Applications folder. It opens the download page, notices by itself when Ollama appears so there is nothing to come back and click, picks a model sized to your Mac’s memory so there is nothing to choose, downloads it with a real progress bar, and tells you when it is ready. No command line at any point.

One thing it will not do, on purpose: download or run the installer for you. The promise this app makes is that nothing happens to your Mac that you did not ask for, and an app that quietly fetches and runs programs has given that away. So that step stays yours — but it is the only one.

You also asked for it written down, and you were right about that too. There is a Getting Started with Ollama chapter in the manual now, its own chapter rather than buried in the long Local AI one, and I have pinned the same thing to the forum.

And a small correction you earned: several messages in the app were telling people to pull an embedding model from a Terminal for something MojoPad has brought its own model for all along. Those are gone. You were sent to the command line for a job the app had already done.

That you asked Ollama how it talks to MojoPad, and then ran the answer through MojoPad’s own summarise button, is the best bug report I have had in a while — because it is exactly what somebody does when the app has not told them.

Mark

4

Wow! It works!

I installed MojoPad-1.59.0 on my Laptop, downloaded Ollama and follwed Ollama’s instructions on the “Quick Start” Page. Clicked on the Ollama.app to activate it, then went back to MojoPad on the Laptop.

I copied a quote from a Kindle source into a page, highlighted it, then clicked on the button in the upper right corner to edit with AI. Ollama did balk, saying I didn’t have a model, but the button was there to install one, which it did.

Activated the edit button again, and selected “Summarize” as the function.

The only unexpected result was that the summary generated by Ollama (which was very good) replaced the original source quotation that I highlighted. Actually, I would like to retain the original and the summarization.

Other than that, the experience for a novice was pretty straightforward and painless.

I would have thought an upgrade of this sort would have taken a month or two (at least it would have in some other applications I have dealt with). Thank you very much.

Ken

1 Like
5

1.59.1 is out, and the summary no longer eats the thing it summarised.

That was not you missing an option — it was the wrong default, and you found a real fault in how that panel is built.

Edit with AI is a copy editor. Tighten, Fix grammar, To action items: for all of those, replacing what you selected is the only sensible outcome, and that is the one thing the panel knew how to do. But Summarize sits in the same list meaning something completely different. A summary is not a correction of the thing it summarizes — it is a new thing derived from it, and the source is usually the point. Especially a quotation you had gone to the trouble of collecting. The panel was doing two jobs and offering one verb.

So there is a second button beside Apply now: Keep both. It puts the result underneath and leaves what you highlighted exactly where it was. Same undo either way, and the same for Make a table, which has the same problem — you often want the table and the list it came from.

And thank you for the verdict on the setting-up. “Pretty straightforward and painless” is the sentence I was hoping for, and it means more coming from you than from anybody else — you are the reason it exists. A week ago the answer to “how do I get started with Ollama” was a paragraph pointing at a Terminal.

There is a pattern here worth saying out loud, because I would like it to continue: you asked for documentation and got the app changed instead, then you asked to keep a quotation and found a design fault in a panel that had been shipping for months. Coming to something new is a genuinely useful vantage point — you notice what the rest of us have stopped seeing. Please keep posting exactly like this.

Mark