This means that there are a lot of dependent services that need to be run first that support the overall execution of the platform.

For e.g. -

Our platform's stack requires SQL Server, Solr, Redis, Postgres, RabbitMQ, MongoDB as core services to be running first.

Once these are all running and available, a service called WebAPI can be run that makes use of some of the above to run as well.

Following this, there are a few more microservices that need to run, but that need not be part of this article since the underlying concept will already come through with the above being demonstrated.

It all started when in practice on a day-to-day basis, whenever I spun up these services, every now and then, at least ONE of them would go down and at best, the error trace was clear enough from the dependent services as to what the issue was.

But at worst, it's a rabbit hole of errors to wade through before I would land on the root cause and if one of the service's unavailability was the cause, I would feel really sad about having lost all that time.

So having gone through this time and time again, I thought I could do something about this.

ITERATION 1 - The first result of this thought was simply - a checklist.

While it got the bare minimum accomplished, in that, I now had a ready reckoner of all the services that needed to be up each time, I had no way of tracking when something went Down during operations. Additionally, if any of the services were not started , either at startup or by me, the service would simply be neglected till such time as an error would alert me.

Rejected coz : Tick-boxes fixed my initial forgetfulness but still left me blind to mid-session crashes.

This was not working out.

Over time, I tried/considered a few more things -

a) writing a script to start them all at once at startup - this failed miserably more often than not since there were some interfering services running because of other ongoing experiments.

b) Creating batch scripts since aliases were missing in Windows and this is predominantly a Windows based platform

c) Docker-izing All the services. But the amount of RAM that was consumed when I ran all the services (except SQL Server and company-specific-services) was a bit more than I liked - speaks to my lack of knowledge in optimizing Docker, I'm sure.

d) I was also suggested a Prometheus dashboard that I summarily rejected because of the unnecessary level of complexity I was inviting for myself for a personal setup. (Although, I Will set something up with Prometheus eventually - just for masochism's sake.)

So after months of this sort of juggling, a few weeks ago, I thought -

Actually let's back up - Iteration 2.

I did not think of Textual right from the start. Because initially all I knew was, I wanted a dashboard that would monitor all the services I have running and I could look at for when something went down.

So the second iteration’s end result was something like this -

Rejected coz : Curling ports gave me machine-readable streaming truth, but looking at raw JSONs is still annoying.

Iteration 3 -

The improvement on the above was a CLI based table with ASCII ✔ and ✖ .
Like so -

Rejected coz : A CLI table with ✔/✖ cut my scan-time, yet wasn’t appealing enough. It’s all about the looks now.

Iteration 4 -

Here is where I thought of Textual. And I asked for a service monitoring dashboard which did not look as plain as the JSON response above nor the Ascii checks . The result was a little error-ridden but this is where Knowing programming while 'vibe-coding' helps.

The changes I had to make were around providing the right command to obtain the statuses of different services, modifying the ports, fixing the styles etc.

After the manual fixes, which admittedly took lesser time than if I'd had to hand-code the whole script, the result was something like this -

NOT Rejected : PROGRESS. Now for the final lap!

Final set of iterations and the end result -

From here on, it was mostly smooth sailing.

I got ChatGPT to fix the universal status symbols to be indicators of Success and Failure - green and red dots, tweak the borders etc.

There were again, obvious AI-slop-ish errors in the code, which again, was fixable trivially.

All in all, the exercise took me less than an hour and I was very happy with it!

Next steps

- I'd like to make this an installer so that it can be easily installed without the dependency installation hassle.

- Want to implement an exponential retry and backoff when a service goes down

- ON/OFF controls for the services

References :

• ChatGippity (to hear Primeagen say it)

• https://textual.textualize.io/

• The Internet

Codebase -

All the code for this project, if you’d like to set it up, can be found here.

Thanks for reading Everything Python! Subscribe for free to receive new posts and support my work.

PS - At the time of this article, we’d just hit 600 readers! Thank you for being one of them!!

Share

I'm going to be presenting a talk at a Mongo DB User group meetup later today and I thought I'd write about it so that it would -

• serve as reading material for meetup attendees wanting to go through the content of my talk later

• let everyone else know what this is all about.

Let me pre-emptively say, I don't know why I chose this to be the "TITLE" of the talk. It is extremely dry. But the topic is actually a lot of fun!

Effectively, there is this concept called Change Streams in Mongo DB and this talk is an attempt to understand and illustrate its usage.

So first off, what is Mongo DB and where is it used?

MongoDB is a database that follows a document model to store data. This means that, in comparison to normal relational databases where data is stored using fixed schemas in rows and columns, Mongo DB and its other Document DB brethren store data in a more flexible format - in JSON-like documents.

Example of a dataset that can be stored in Mongo :

{
  "_id" : ObjectId(),
  "title" : "Anna Karenina",
  "author" : "Leo Tolstoy",
  "content" : "It's a classic of world literature, exploring themes of love, loyalty, family, and social class in 19th-century Russia.",
  "tags" : [ "Russian" , "Serious" ],
  "publishedDate" : ISODate()
},
{
  "_id" : ObjectId(),
  "title" : "War and Peace",
  "author" : "Leo Tolstoy",
  "content" : "Set during the Napoleonic Wars and focusing on several aristocratic families in Russia.",
  "tags" : [ "Russian", "Serious" ],
  "publishedDate" : ISODate()
}

MongoDB can be used where the data to be stored doesn't particularly benefit from being modelled into strict tables. It can be used when the data schema needs to be more flexible.

For example, the same data above could have potentially been stored in a Relational DB. But as the number of fields increases and as there end up being more and more complicated JOINS, the Relational DB model might suffer from slowdown.

What are Change Streams?

This is a feature that has been around for a long time now. We're currently on Mongo DB 8.0.4 as of December 2024 but this feature was introduced in MongoDB 3.6 in 2017.

It is used to let applications access real-time data changes in Mongo DB. Without having to keep polling for it.

Now other DBs also have this in some shape or form but they all vary in difficulty levels of configuration -

• Postgres apparently has support for a Debezium connector that can be used for Change Data Capture (CDC). Never tried it but I think I will after this!

• Amazon's DocumentDB also has Change Streams but it might need additional configuration compared to Mongo DB.

• Relational DBs can be configured to use Triggers or Log based CDC but it can impact performance or needs some non-trivial know-how.

In that aspect Change Streams are very easy to configure.

How do Change Streams work?

• This whole mechanism hinges on the fact that Mongo DB relies on "op-log" or operations-log based replication. An op-log is basically a record of all operations performed on data in any collection/database in MongoDB.

• What this means is that if Mongo DB is configured to use a replica set, any changes that are made to the DB are written to the op-log by the primary node. Secondary nodes read /tail the oplog and apply changes in the same order.

• Change Streams can be used by using a "watch" method on a collection, a database or a whole cluster.

• So now, whenever there's a certain operation-based change on the "system" under watch, the change stream captures it from the corresponding oplog entry.

• The operations supported are : insert, update, delete, replace , invalidate

How can I enable Change Streams?

This post assumes you have a working MongoDb setup - I'll write a separate post for this.

• Go to the Mongo Shell and execute rs.status()

If there's a replica set configuration like so -

you're all good. If not, you need to do the following :

• Stop the mongo service - Either from Task Manager if you're on Windows. Or using sudo systemctl stop mongod if on Linux.

• Find the mongod.cfg (Windows) or mongod.conf (Linux) file and add the following line

replication:
	  replSetName: "<Whatever name you want>"

So it looks like -

• Restart the Mongo service.

• Reopen the Mongo shell and run rs.initiate()

Boom! Change Streams are now enabled!

Great. Now how do I use them?

I thought about this a lot as well. My initial thought was to mimic the functioning of an oxymeter in a hospital that keeps reporting the oxygen level of a patient.

But I thought I'd keep it a little lighter.

So, my simulated use case is one of segregating News Items into 1 of 4 categories as they keep getting pulled from News Sources.

Here's a broad architecture diagram -

Let's consider this piece by piece :

News Generator :

• Here we have 5 "news sources", producing news items every, say 10 seconds.

• The item , which here is a string is sent to an Azure OpenAI LLM instance with a prompt designed to return the "Category" of News it belongs to. We have a preset expectation of news items to fall under 5 categories : "Sports", "Politics", "Entertainment", "Tech", "Misc".

  You don’t have to use Azure OpenAI. You can use any model you have access to!

• I'm using gpt-4o for this example but it's such a trivial activity that most older or any Small Local Model should also suffice for this task.

• What is not shown in the diagram is that I'm using Opik (launched locally) to track my LLM calls.

• Now as soon as this categorization is obtained, the data is pushed into a collection called "articles" under a DB called "newsDB".

The Flask App

• This doesn't necessarily have to be a Flask app. Pick your web server of choice - FastAPI, Django, Bottle, whatever you want. But yes, in this example, it is a flask app.

• Here, I do a few things :

  • Make sure the Mongo DB is connected to on port 27017 (default) and that the UI reflects the number of pre-existing records for each category in the DB. For a fresh start, that number is 0 for all categories.

  • Set up a collection.watch() on the articles collection so that the change stream can be captured.

  • Start the flask server using websockets (via flask-socketio) so that a steady, bidirectional connection is established between server and client. This way, the browser is always watching for any changes that the DB is ready to communicate back without needing a refresh of the screen.

The Client/ UI/ Browser

• If the server is started on say, port 5002, I navigate to http://localhost:5002

This changes automatically every 20 seconds (since that’s what I’ve configured underneath. You can set your own value.)

Because of Change Streams, with each article being produced and categorized, the DB’s state is Almost Immediately informed to the application.

This is something we'd have had to poll the DB regularly for, if this feature weren't there. And because we use websockets, the updated state of the DB can directly go from server to client I.e UI/the browser as well.

Now, are there any disadvantages to using Change streams? Absolutely. Since the op log is continuously, automatically being watched and tailed, there is a bit of a compute impact. But if the application demands near-realtime updates, that additional compute is the price to pay for the feature!

Hopefully this gave you an idea of how Change Streams can be used!

Codebase -

All the code for this project can be found here.

Why would I want to do this?

Fair question to ask in the face of so many ubiquitous LLM offerings present like ChatGPT, Claude, Gemini etc. Why do I even want to set up an LLM locally? I asked ChatGPT this and it told me a lot of what I was thinking along the lines of - like privacy, to prevent reliance on possibly unreliable internet and it kept going for a while, so I asked it to -

Setting up Ollama -

• Depending on your operating system, download the corresponding Ollama executable from the official website.

• Once you download and run it, it should be running as a small service in the background of your operating system. For example, if you're on Windows, you should be able to see it running on the tray on your screen's bottom right corner.

  If you’re on a Mac, it should show up on your Menu bar like so -

  

  • To test that it’s working, open up a CMD or a Terminal instance and type :

    • ollama -h

      

• To download any existing models, fetch them from the Ollama Models page and pull them locally using ollama run

• For example, I want to run one of the latest models - olmo2

  Once that model is pulled, the prompt looks a little like this -

  

• Smaller models are better for lower config laptops/desktops.

This section is optional.

The next thing to do to mimic a local Chat-GPT-ish experience is to hook this backend Ollama server to a front-end web interface. This is where https://openwebui.com/ comes in.

Setting up OpenWebUI -

The Github README for OpenWebUI is extremely helpful. A few months ago when I tried it out, they only had the Docker based offering but now it seems that all that is to be done to set it up is -

• Create and activate a virtual environment

• uv pip install open-webui

• open-webui serve

So when you visit localhost:8000 on your browser you should be able to see a chatgpt-ish interface and the list of models you downloaded on Ollama on a top-left corner dropdown.

Performance

• "How fast is it?", a friend asked. It's not going to be comparable to OpenAI/Claude/Gemini server speeds given that it is limited by your local laptop's CPU/GPU. But on a Mac M1 or a Windows i5 with 32 GB RAM, it's able to run and engage in processing and conversations at fairly decent, tolerable speeds.

What are my other options?

There's a couple of other options like LMStudio and Msty, but those are "left as an exercise to the reader" to try out. :D

Happy local chatting!

If you found this useful, please share it with your friends and ask them to subscribe to EverythingPython as well!

Subscribe now