josef.digital

How josef.digital Uses Ollama and Mistral 7B to Build Cloud AI Products

At josef.digital, we’ve shifted fully into AI product development. We’re using Ollama with the open-weight Mistral 7B model to power a range of AI agents that we run in our own infrastructure.

We run Mistral 7B in containers using Docker, deployed to a dedicated cloud droplet. The Ollama API gives us a fast local inference layer that we integrate directly into our backend services using Tornado (Python).

This setup is: • Fully containerized • Self-hosted in the cloud • Low-latency and cost-efficient • Easily adaptable for different client-facing AI tools

We’re actively building products around this stack and will continue expanding on it as we roll out more features.

🌪 Why Tornado?

We chose Tornado as the foundation for our emailer API because of its: • High-performance Asynchronous Capabilities: Tornado’s non-blocking I/O makes it ideal for I/O-bound tasks like SMTP communication and logging. • Minimal Overhead: It gives us full control of the request/response cycle, which is ideal for building a focused microservice like our emailer. • Production-Proven: It’s been battle-tested in real-time systems and scales well under load, fitting our needs without unnecessary complexity.

⸻

📤 The Emailer API

The emailer API is a Tornado application designed for one job: sending and tracking outbound emails. • Accepts Messages via HTTP: Our internal systems (like contact forms and platform notifications) POST to this API. • Formats and Dispatches Emails: It constructs well-formatted messages and sends them using SMTP or third-party services (e.g., Mailgun, Postmark) depending on configuration. • Responds Quickly: Because of its async architecture, it responds instantly while offloading heavy tasks to the consumer.

⸻

🔁 The Consumer Service

Alongside the API, we run a separate Python consumer service that: • Subscribes to ForestMQ Topics: It listens for new email jobs sent through our internal message queue. • Handles Retries and Failures: With support for retry policies and exponential backoff, it ensures that messages are delivered even if a provider temporarily fails. • Maintains Delivery Logs: Every sent email is tracked, logged, and stored in a backend for observability and audits.

⸻

🔐 Security & Reliability • All requests are authenticated using bearer tokens across internal services. • Structured JSON validation prevents malformed payloads. • Idempotent operations ensure duplicate messages aren’t sent.

⸻

🛠 Developer Experience • Easy Testing: We use pytest for unit tests and standalone Tornado test clients for integration testing. • Simple Deployment: The API and consumer are containerized and deployed via Docker Compose using Ansible. • Real-time Logging: Logs are streamed to the platform dashboard via JSON logs, helping us monitor email delivery live.

⸻

🚀 Conclusion

By splitting email responsibilities between a dedicated API and a lightweight consumer, and leveraging Tornado’s async strengths, josef.digital has built a modular, scalable, and reliable email system. It’s fast, focused, and integrates cleanly with the rest of our platform — ensuring users receive messages at the right time, every time.

⚛️ How josef.digital Builds Modern Frontends with React, Redux & RamdaJS

At josef.digital, delivering highly interactive, maintainable, and scalable user interfaces is central to the work we do. We rely on a modern JavaScript stack — primarily React, Redux, and RamdaJS — to build frontend experiences that are both performant and developer-friendly.

⸻

⚛️ Why React?

React is our frontend framework of choice for building fast, component-based UIs. It allows us to: • Compose Reusable Interfaces: We break down complex UIs into atomic components to encourage reuse and reduce duplication. • Build Reactive Interfaces: React’s declarative approach makes it easy to reason about state changes and render logic. • Stay Ecosystem-Aligned: The huge community and robust tooling (like React DevTools and Vite/Webpack) accelerate our velocity.

⸻

🧠 Why Redux?

Though React has matured with built-in state tools, we still choose Redux for complex apps where global state needs to be explicit, testable, and predictable. Redux helps us: • Centralize Application State: It becomes the single source of truth, which is critical for features like undo, replay, or time-travel debugging. • Maintain Predictability: With pure reducers and action-based state changes, we maintain a high degree of clarity and testability. • Support Asynchronous Flows: Middleware like Redux Thunk or Redux Toolkit Query helps us manage data fetching and side effects cleanly.

⸻

🔧 Why RamdaJS?

We use RamdaJS as a utility belt for functional programming in JavaScript. Ramda encourages: • Immutability: We avoid mutations and work with pure functions, especially in reducers or data selectors. • Function Composition: Building complex transformations out of simple, composable functions improves readability and testability. • Declarative Logic: Ramda allows us to describe what we want to do with data rather than how, making business logic easier to maintain.

⸻

🧩 How It All Comes Together

We typically structure apps with: • React for rendering the UI • Redux as the state manager (sometimes Redux Toolkit if appropriate) • Ramda for data transformation, often in selectors, reducers, or utility modules

This combination supports high-confidence development, particularly in projects involving complex user interactions, API data, or business logic.

⸻

🧪 Testing & Developer Experience • Redux DevTools for inspecting state • React Testing Library for testing components the way users interact with them • TypeScript for static type safety • Jest & Vitest for fast unit and integration testing

⸻

🌱 Scaling the Stack

As our projects grow, we continue to explore enhancements like: • Code splitting and lazy loading for performance • End-to-end testing with Playwright • Runtime type validation with Zod or io-ts for safer API interactions

⸻

🚀 Conclusion

Using React, Redux, and RamdaJS gives josef.digital a powerful and reliable frontend stack. It’s a blend of declarative UI, predictable state, and functional clarity — helping us ship beautiful, robust interfaces faster.

⚙️ How josef.digital Leverages C for High-Performance Messaging with ForestMQ

josef.digital is a fast-moving software agency and product studio focused on building efficient, maintainable platforms. While much of our application logic is written in high-level languages like Python and Go, we use C at the core of one of our most critical internal tools: ForestMQ.

⸻

🌲 What is ForestMQ?

ForestMQ is a lightweight message queue written in C, designed to be ultra-fast, memory-efficient, and simple to deploy. It serves as the backbone of internal messaging at josef.digital, powering job queues, asynchronous event handling, and microservice communication.

⸻

🧠 Why We Chose C

Using C allows us to: • Maximize Performance: With C, we get close-to-the-metal speed for handling thousands of messages per second with minimal overhead. • Minimize Dependencies: ForestMQ runs with no external runtime or virtual machine, making it ideal for containerized environments. • Build Custom Protocols: C gives us full control over binary and text-based protocol implementation, which is crucial for supporting standards like AMQP or custom formats.

⸻

🔄 Where ForestMQ Fits In

We use ForestMQ across multiple parts of our infrastructure, including: • Email Dispatch: Our transactional email service receives messages via ForestMQ to decouple frontend interactions from backend delivery. • Uptime Monitoring: A worker service periodically checks endpoints and reports failures, all coordinated through ForestMQ. • Background Processing: Time-consuming operations such as analytics processing, scraping, and backup jobs are routed through the queue.

⸻

📦 Benefits of Our C-Based Queue • Blazing Fast I/O: Low-level networking means fast message delivery with minimal CPU usage. • Memory Efficiency: With control over allocations and buffer reuse, ForestMQ operates well in memory-constrained environments. • Extensibility: Written in plain C, it can be compiled and embedded into other native projects or exposed via APIs.

⸻

🔍 The Bigger Picture

While most modern systems can rely on established solutions like RabbitMQ or Redis Streams, ForestMQ gives us full ownership over performance and features. It’s not just about speed — it’s about clarity, control, and maintainability.

⸻

📈 What’s Next

We’re expanding ForestMQ to include: • AMQP 2.0 support (in active development) • Persistent queues with disk-based durability • Enhanced observability for metrics and debugging

⸻

✨ Conclusion

At josef.digital, using C where it counts lets us push the boundaries of what’s possible with lightweight infrastructure. ForestMQ is a key part of that — and proof that choosing the right tool, even if it’s low-level, can pay off massively when done with care.