Hippo Reads provides a link between well-researched academic and journalistic materials and real world issues. It offers three services: Hippo Reads curations, which feature in-depth examinations of topics along with suggested reads; Hippo Thinks, (services for Thought Leaders), which brings together high-profile industry thought leaders, writers, and academics to produce substantiated articles for mainstream media; and Hippo.Edu, which aims to instill a learning passion among grades K-12 students by discovering real-world academic application with guest lecturers.

Hippo Reads

THE BEGINNINGS, THE RISE, AND THE DIVISIONS OF CHRISTIANITY

If you’re not very deep into the cultural landscape of software developers (or sysadmins, DevOps engineers, SREs, or anyone else who works with code for that matter…) you probably haven’t realized that the community has their own style for article and conference talk titles. developed coded To be honest, this feels like an odd topic for a blog post. You don’t see a lot of interest in the quirky writing and title-picking tendencies of the coder world, but after following this industry for 11 years, I feel like a few newer entrants to the tech field could benefit from knowing how to entice interest from the rest of the community. You can find a bunch of great resources on how to write a good blog title — and I encourage you to read those — but there’s almost zero good advice out there right now on writing a great title for our niche audience. generalized That brings us to the question: who am I writing this for? Maybe it’s people who are just starting out in the coding world and want to spark a little more interest in their blogs or talk submissions. Maybe you work in developer relations, advocacy, or content marketing and want to create things that appeal to this demographic. Or maybe you’re a veteran coder who will find this list entertaining — nodding along and enjoying the cleverness of our in-group (or perhaps you can tell me why people say “learn you a Haskell for great good” — I still don’t get it). Maybe this will help you clickbait your way to the front page of HackerNews or have the most attended talk of that conference you’re submitting an abstract for. Whatever your reasons for checking this out, I now present my definitive list of catchy title ideas for the world of programming. I’ll be using variables X and Y to denote a blank space in a title where any topic or adjective can go. Why X? Why Ruby? Why React? Why Multicloud? These titles ask the question: “Why would I want to do or use this thing?” It just takes that question and makes it a lot more terse. (Learn) X the Y Way Learn Python the Hard Way Kubernetes the Hard Way Learn Rust the Dangerous Way Finding bugs in SQLite, the easy way was the book that got “the hard way” title trending. Why would you want to learn something the hard way? Well, the rationale is that it sticks in your memory better when you learn things without a lot of shortcuts and abstractions. Learn Python the Hard Way X The Right Way PHP: The Right Way JavaScript: The Right Way This title is more gutsy, but it works because even though people realize that there’s no one “right” way to do everything, they want a solid, well-tested pattern so they don’t have to figure out their own. X: The Y Guide JavaScript: The Definitive Guide Java Programming: A Practical Guide Optionals In Swift: The Ultimate Guide Centering in CSS: A Complete Guide How to Deploy Mongo on AWS using Docker: the definitive guide for first-timers The Essential Guide to Building Balanced Development Teams The No-Nonsense Guide to JVM 14 Memory on Kubernetes Absolute Beginner’s Guide to Programming Kubernetes for the Busy Developer You can get really creative with this one. I like the titles that mention a target audience, such as: The (Beginner’s, Absolute Beginner’s, Freelancer’s, Busy Developer’s, Hacker’s, etc.) Guide. X Considered Harmful Go To Statement Considered Harmful Docker Considered Harmful Javascript Cryptography Considered Harmful Software Patents Considered Harmful “Considered Harmful” Essays Considered Harmful In programming, this title template started in 1968 with Edsger Dijkstra’s letter: “Go To Statement Considered Harmful”. Now it’s mainly used in alarmist essays or mildly alarmed essays that just want a clickbait title — but hey, that’s what you’re here for isn’t it :) X Explained DevOps Explained Angular 2 change detection explained RAFT Explained – Part 1/3: Introduction to the Consensus Problem X Demystified Open Source Software: Demystified Kubernetes Networking Demystified: A Brief Guide Demystifying Service Mesh Thought about getting “Technology Demystifier” on my last set of business cards. X and Y: Better Together Distributed Tracing & Logging - Better Together Vault & Kubernetes: Better Together Ansible and HashiCorp: Better Together A Bunch Of Great Strategies For Using Memcached And MySQL Better Together This is sometimes (but not always) used to propose that two potentially competitive tools or ideas be used together rather than a one-or-the-other scenario. Think of all the initial enemies that work so well together, together like Goku and Vegeta, Rey and Kylo Ren, or pineapple and pizza! (Just kidding about that last one. I’m not a monster.) The X Handbook (or Pocket Guide) The Next.js Handbook The Python Data Science Handbook SQL Pocket Guide: A Guide to SQL Usage Bootstrap Pocket Guide I miss the more comprehensive guides and the olden days of pocket-sized sysadmin reference guides. I say bring back more “handbooks” and “pocket guides”! Sure software books are out of date in 6 months these days, but instead we can make frequently updated web guides that look great on our phones can’t we? X the Missing Manual WordPress: The Missing Manual cglib: The missing manual Docs as Code: The Missing Manual This one was actually a running series of books as well as a potential talk or blog title. It indicates coverage of a topic that hasn’t been documented as comprehensively or clearly as the author would like. A Gentle Introduction to X A Gentle Introduction to Deep Learning for Graphs A Gentle Introduction to Programming Using Python A Gentle Introduction To Rust The alternative to “The Hard Way”. [Insert pop-culture referencing title here] One Does Not Simply Put Machine Learning Into Production Keep it Safe… Keep it Secret Automate All the Things! Call Me Maybe: MongoDB Stale Reads Buttons that Spark Joy Winter is Coming For Java Updates Clever, humorous, culturally relevant titles always get my attention. Keep your references fresh, my friends. The Hitchhiker’s Guide to X The Hitchhiker’s Guide to Javascript The Hitchhiker’s Guide to Terraform Your Infrastructure Hitchhikers guide to Haskell This might be the most popular of the pop-culture reference titles. [Insert pun-ny title here] Look What You MIDI Me Do! Can’t Contain your Excitement about Containerization? At Your Microservice The world needs more of these. Everything You Need to Know about X, Things Every X Should Know Everything You Need to Know About OAuth (2.0) Everything you need to know about cryptography in 1 hour Everything you need (and don’t need) to know about PHP’s type system 97 Things Every Cloud Engineer Should Know It’s a little arrogant to say you know what we need to know, but I guess it’s meant to mean something like ‘the basics that matter when you’re starting out with a new topic.’ Or maybe it will also include some pitfalls not easily found in the documentation. X in a Nutshell Java in a Nutshell: A Desktop Quick Reference I I2C in a Nutshell Kubernetes and Virtual Kubelet in a nutshell X in Plain English Amazon Web Services (AWS) in Plain English Functors, Applicatives, and Monads in Plain English Software Licenses in Plain English Because sometimes these complex topics feel like they’re described in a foreign language. Of course, if you don’t speak English that well, this type of article might not interest you. Maybe you need something like “X in Plain French”. X: Explain it like I’m 5 Explain like I’m 5: DNS Explain functional programming to me like I’m five Explain it to me like I am a 5-year-old: What are Docker, Image, and Containers Because sometimes plain English isn’t enough. Sometimes things need to be explained in the simplest terms possible. X in Y Minutes Awk in 20 Minutes 90% of Python in 90 Minutes Learn Lua in 15 Minutes Isn’t it great to know how long something will take ahead of time? Although if it’s anything like the estimated cooking times I see on recipes, it’ll probably take me twice as long. X for Fun and Profit F# for Fun and Profit Distributed systems for fun and profit Tagging Docker Images for Fun and Profit Who says you can’t have fun make a profit? and X: Friend or Foe? CSS Overrides: Friend or Foe? Const - Friend or Foe in C++? Local Variable Type Inference: Friend or Foe? Friend or foe… what about a frienemy? X: The Good Parts JavaScript: The Good Parts JavaScript: The Evil Parts git log – the Good Parts AngularJS: The Bad Parts I think this was popularized by the famous book “JavaScript: The Good Parts”. Now people get creative by putting any adjective before “Parts”. X is Over/Broken/Bullshit The Windows era is over Data denormalization is broken “Cultural Fit” Is Bullshit If you’re feeling edgy or wanna be controversial. X: Stories from Trenches PostgreSQL Search: From the Trenches Kotlin From The Trenches 10 best sysadmin stories from the trenches Vault Configuration as Code via Terraform: Stories From the Trenches at Hippo Technologies Because code is war. The Life of a X The Life of a Data Byte The Life of a Packet Through Consul Service Mesh The Life of a Serverless Microservice on AWS Because code is life. The Art of X The Art of Writing Scripts for CI/CD The Art of the Error Message The Art of Assembly Language The Art of Interrupting Software Engineers For those topics that are more of an art than a science. Cheat Sheets, Checklists, or Quick References Front-End Performance Checklist 2020 API Security Checklist Rust Language Cheat Sheet Shell Script Brackets Cheat Sheet From C to C++: A quick reference for aging programmers Linux Quick Reference Guide Once you already know something but don’t want to have to remember every detail, that’s when you want a quick reference or checklist. Make one of those for a topic where one is badly needed and you’ll get plenty of views with a simple title like these. Learn You a X for Great Good Learn You a Haskell for Great Good! Learn You Some Lisp for Great Good Learn You Some Erlang for Great Good! Learn You an Elm I don’t know where this weird phrase comes from, but it’s truly a thing. If you know, tell me in the comments. Does it have something to do with the syntax of functional programming? X is Your Friend / Not Your Friend A new addition to this article (2021).  Basically another way to say "x is great" or "x considered harmful". The Last / Only X You'll Ever Need Another way of saying a "definitive" or comprehensive guide that obviates the need to read any others. The last S3 security document that we’ll ever need, and how to use it Go Forth and Write Catchy Titles! Well I hope that wasn’t a waste of your time. Now, as conference seasons approach and you have some time to work on talk submissions or blog posts, this list can give you some ideas for the title of your content or maybe even inspire the topic you choose to cover. total

How to Clickbait a Developer: 105 Catchy Title Trends

Astounding Stories of Super-Science May 1931: VOL. VI, No. 2 - The Readers' Corner

If you enjoy this essay you can find some others about , and . My most popular essay at the moment is Happy reading! growth strategy acquisition debunking the difference between cost per acquisition and customer acquisition cost. We all have emotions, even in B2B There’s a stigma in business. People say B2B buying is rational and emotionless when compared to B2C. Do you agree? It’s of paramount importance that those in B2B, whether you’re in marketing, sales, operations or product, understand the emotional aspects of the buying journey. It’s very easy for us to remain in the stigma and blindly believe the B2B buying process is just rational and emotionless. In B2B marketing specifically, we need to craft, create and communicate emotional hooks and stories for our buyers to enter our marketing and sales funnels. From there, our content, copy and creative must continually tap into the buyers emotions to keep the buying intent as high as possible. That’s all well and good, but it still misses a key ingredient. We haven’t taken into account which has nothing to do with your product, service or value prop. the act of buying — If we as B2B marketers and sellers understand the emotions triggered in the act of buying, then we will set ourselves up for more success. Those who take out the friction of B2B buying will win. As , VP of Marketing at says: Dave Gerhardt Drift “whoever makes it easier to buy wins” The act of buying A wise man once said: “It’s not a problem if you buy the wrong can of soda” A can of coke is 70p. No big deal if you accidentally get full fat coke rather than Coke Zero. It would be an issue, however, if buying that can of coke had multiple stakeholders, took days to drink (implement), had to sign a binding contract, pay at least a few hundred dollars a month and get sign off from the c-suite. There’s so much more at stake in B2B buying, which makes it more emotional than B2C. 3 main reasons: 1. People Buying journeys tend to follow hive mentalities. It’s not just 1 person in a business tasked with buying software. There’s a team working on the project. And you know what a team is made up of? People. The more people in a team leads to more opinions, feelings and indecision. Luckily teamwork is one of my strengths, but for some it can be hard to grasp. Working together on something can bring up , and , especially when there’s pressure involved in deciding the best product, service or solution for your business. So yes, people is a big factor. tensions conflicts heavy debate 2. Cost If you were responsible for buying software that cost £1 a year, then easy peasy — let’s buy every piece of software out there. But sadly it’s not like that. For a tool that costs circa $1,000 per month, you’re spending upwards of $12,000 — what’s that in proportion to what you’re generating for the business? Or even tougher, your salary? Maybe you’re the HiPPO (highest paid person in the room) and it’s peanuts in comparison — good on you. If not, the stakes can feel a lot higher as will your emotions. The higher the cost, the higher the stakes. The higher the stakes, the higher your emotions. Emotional steaks for dinner 3. Reputation You may not know it already — but being accountable for buying a piece of software has huge implications on your reputation within a company. You are effectively stamping your name on the purchase saying “my name is Rupert and I approve this tool”. If you’re the one who led the project and ultimately made the decision, then you’re the one who’s held accountable. The pressure is on. And that scenario sends your emotions running high. In B2C, reputation isn’t an issue. It’s not on the line if you buy a can of Coke, buy the premium package on Evernote or purchase a cheap domain for your blog on GoDaddy (those are pretty random examples), but you get my point. If being held accountable, reputation is a factor in the mix. Conclusion B2B buying journeys are more emotional than B2B. It involves more people to make a decision, tends to cost a lot more and your reputation is on the line. That is the recipe for an emotional roller coaster. If we can make the act of buying as frictionless as possible, taking into account people, cost and reputation, then you are setting yourself up for success. Don’t forget what , VP of Marketing at says: Dave Gerhardt Drift “whoever makes it easier to buy wins” What do you think? As always let me know your thoughts. If you found this interesting and think your colleagues, friends and family would benefit from reading it then give this a share and a 👏! It’s wildly appreciated! If you enjoyed this essay then you can find some others about growth , strategy and acquisition . My most popular essay at the moment is debunking the difference between cost per acquisition and customer acquisition cost.

3 reasons why the B2B buying journey is more emotional than B2C

Having the correct data to support your use case is essential to a successful implementation of LLMs in any business. While most out-of-the-box LLMs are great at tasks, they can struggle with specific business problems. They didn’t train on the data for your business problem, so they don’t have adequate context to solve it. general Businesses often have a treasure trove of internal data and documents that could meet this need for specific context. But, here’s the question: How do we integrate all this useful data (context) into the LLM without doing resource-intensive and time-consuming retraining or fine-tuning the LLM? The answer is (RAG), a technique that enhances LLMs with just-in-time retrieval of close context information. retrieval-augmented generation In this post, we’ll walk through how to use and to implement the storage and retrieval of this contextual data for an LLM to use. We’ll solve a context-specific problem with RAG by using LlamaIndex, and then we’ll deploy our solution easily to Heroku. LlamaIndex LangChain Before we start coding, let’s quickly cover the core concepts. A brief introduction to RAG and LlamaIndex When you ask your LLM a question that requires context to answer, RAG retrieves that contextual data to help the LLM give a more accurate and specific response. It’s like having a sous chef quickly run out to the farmer’s market to get the freshest ingredients that weren’t in the pantry so that the executive chef can cook up the perfect dish with all the necessary ingredients. One key to how the RAG workflow can provide context is using vector databases and vector search indexes. Let’s break down some of the core concepts and what this all entails. A is a set of coded numbers that represent the meaning and context of a piece of text (such as a word, phrase, sentence, or even an entire document). vector An is the actual numerical values in a vector; but most people tend to use the terms “vector” and “embedding” interchangeably. embedding An has been trained on documents so that it can convert newly input text into vectors. Not all texts talk about the same things or in the same way — consider a set of academic research papers versus a set of marketing materials. So, we have different embedding models — each trained on specific datasets with specific goals in mind. embedding model Using an embedding model, we can create embeddings from documents, breaking the text in those documents down to their coded numbers. Creating an embedding might involve a strategy like , which splits large documents into smaller, manageable pieces. From there, each chunk is converted into an embedding. document chunking When you query a , your question is turned into an embedding and compared against all of the other embeddings stored in a vector database. When you build a , you can perform very fast and accurate vector searches (also called similarity searches). Using vector databases lets you perform fast and accurate searches — not merely to match the presence of a specific string like in traditional databases, but to match for documents that are similar in with the words you used. vector database vector search index meaning Within the context of RAG, we use our original prompt to perform a vector search against all of the documents in a vector database. Then, those matching documents are sent as context to the LLM application. The LLM now has a set of detailed notes to refer to when crafting its answer to the original prompt. LlamaIndex is a crucial framework that simplifies the process of integrating, organizing, and retrieving private or specialized data. It will help us with creating the document embeddings and vector search index. Then, we’ll lean on LangChain to piece it all together, executing the similarity search and sending the results to our LLM to fetch a response. Together, LlamaIndex and LangChain provide a secure and dependable solution for handling the RAG workflow. Are you ready to build something? Here we go. An introduction to our demo project The best way to learn about RAG with LlamaIndex and Heroku is to build a small sample application. For our purposes, let’s pretend we work with , a library of over 70,000 free ebooks. We want to build an LLM-based chatbot that can answer specific questions about the free books in the project. Project Gutenberg This is the perfect use case for using RAG, and we can use LlamaIndex to take advantage of the large corpus of book texts available to us. To keep our project simple, we’ll use , a popular book from AD 401. The Confessions of St. Augustine The codebase for our completed project can be found in this . If you prefer, you can clone the repo and deploy the application to Heroku. Or, you can follow along step by step to see how we got the code that we did. GitHub repository We’ll follow these general steps: Set up our project. Load the data. Build the index. Store the index. Integrate LangChain. Deploy to Heroku. Step 1: Set up our project Create a new folder for your Python project. Then, activate a and install the initial dependencies that we will need. venv (venv) ~/project$ pip install llama-index langchain langchain-openai Next, we’ll load the data to be indexed. Step 2: Load the data When building an index of internal data for use with RAG, you must gather all your data (text) into a single place. In our example case, that's the text of the book we mentioned above. This is the context that we will soon convert to a vector index of embeddings using LlamaIndex. In the typical use case, your context data will be a large corpus of text that fits the business problem you're trying to solve. For our mini demo, we'll create a subfolder called , and then we'll download the book as a single file in that folder. data (venv) ~/project$ mkdir data

(venv) ~/project$ curl https://www.gutenberg.org/cache/epub/3296/pg3296.txt -o data/confessions.txt

(venv) ~/project$ ls data
confessions.txt Step 3: Build the index After gathering all your data in a single directory, it’s time to build the index. We’ll write a simple Python application that will use LlamaIndex to index the data, and then we’ll query our index. For this to work, you will need an OpenAI account and API key. This is because LlamaIndex uses as the . (Changing those defaults is outside the scope of this article.) OpenAI’s text-embedding-3-small default embedding model In our project root folder, we create a file called . The initial contents look like this: index.py # index.py

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
import os

if os.environ.get('OPENAI_API_KEY') is None:
  exit('You must provide an OPENAI_API_KEY env var.')

documents = SimpleDirectoryReader("data").load_data()
index = VectorStoreIndex.from_documents(documents)

query_engine = index.as_query_engine()
response = query_engine.query("In which city is Saint Augustine the Bishop?")
print(response) We run our file and receive the expected response: (venv) ~/project$ OPENAI_API_KEY=sk-******** python index.py
Hippo Of course, we can double-check our data. Looking at the first few lines of the book, we see: THE CONFESSIONS OF SAINT AUGUSTINE

By Saint Augustine

Bishop of Hippo As you can see, LlamaIndex did its job. Our Python application completed our question exactly as we would expect from the vector-indexed data. Step 4: Store the index It’s important to note that, in the above example, we only store our indexed data in memory and not on a disk. Our index — now a series of vector embeddings in memory — will be lost completely after we make our call to the OpenAI model and finish the workflow. Creating a vector index (embeddings) for our text isn’t , so we don’t want to have to recompute those results every time we call the model. It’s best to have a separate workflow where we persist the index to disk. Then, we can reference it at any time later. free A common approach to doing this is to store embeddings in a PostgreSQL database and use to perform similarity search. To keep our demonstration simple, we’ll just store our indexed data as flat files. pgvector So, we add this simple step to our file: index.py PERSIST_DIR='./my_vector_indexes/gutenberg/'
index.storage_context.persist(persist_dir=PERSIST_DIR) Now, after we run our file, we can check for our stored index. (venv) ~/project$ OPENAI_API_KEY=sk-******** python index.py
Hippo

(venv) ~/project$ tree
.
├── data
│   └── confessions.txt
├── index.py
└── my_vector_indexes
    └── gutenberg
        ├── default__vector_store.json
        ├── docstore.json
        ├── graph_store.json
        ├── image__vector_store.json
        └── index_store.json

3 directories, 7 files Step 5: Integrate LangChain We’ve learned the basics of what a vector index store is and how easy it is to build one. But, to actually build an end-to-end application that chains it all together, we use . This way, we can deploy our solution as an API. Let’s rewrite our index.py code to be a bit more production-worthy. LangChain We’ll show the code below and then explain what we’re doing after. It might look like a lot of code, but we are only adding a few new steps. # index.py

import os
from langchain_openai import ChatOpenAI
from langchain.chains import ConversationalRetrievalChain
from langchain.memory import ConversationBufferWindowMemory
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
from langchain_community.retrievers import LlamaIndexRetriever
from fastapi import FastAPI
from pydantic import BaseModel

if os.environ.get('OPENAI_API_KEY') is None:
  exit('You must provide an OPENAI_API_KEY env var.')

documents = SimpleDirectoryReader("data").load_data()
index = VectorStoreIndex.from_documents(documents)

# For this demo, we will not persist the index.

retriever = LlamaIndexRetriever(index=index.as_query_engine())

llm = ChatOpenAI(model_name="gpt-3.5-turbo", max_tokens=2048)

memory = ConversationBufferWindowMemory(
  memory_key='chat_history',
  return_messages=True,
  k=3
)

conversation = ConversationalRetrievalChain.from_llm(
  llm=llm, 
  retriever=retriever,
  memory=memory,
  max_tokens_limit=1536  
)

class Prompt(BaseModel):
  question: str

app = FastAPI()

@app.post("/prompt")
async def query_chatbot(prompt: Prompt):
  response = conversation.invoke({'question': prompt.question})
  return response['answer']

if __name__=='__main__':
  import uvicorn
  uvicorn.run(app, host="localhost", port=8000) First, notice that we are now directly using LangChain and OpenAI. We set up our along with some so that our can be “remembered” across subsequent queries. Now, we have an actual ChatBot which we can interact with. llm memory conversation From there, we use to create an API server that listens for requests on the endpoint. Requests to that endpoint are expected to have a request body with a question, which is then passed (along with context from our vector index) to the LLM. FastAPI POST /prompt We use to spin up our server on port 8000. uvicorn Before we can start up our server, let’s add those new Python dependencies: (venv) ~/project$ pip install fastapi pydantic uvicorn Now, it’s time to test. We start by spinning up our server. (venv) ~/project$ OPENAI_API_KEY=sk-******** python index.py
INFO:     Started server process [1101807]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://localhost:8000 (Press CTRL+C to quit) In another terminal, we send a curl request to our endpoint. $ curl -X POST \
       --header "Content-type:application/json" \
       --data '{"question":"Who is Ambrose?"}' \
       http://localhost:8000/prompt

"Ambrose is a person mentioned in the text provided. He is described as a
respected and celibate man who was esteemed by the author. Ambrose is depicted
as a figure of great honor and excellence, particularly known for his
dedication to reading and studying." Success! Our vector index appears to be up and running, and our chatbot is fully functional. It’s time to deploy. Step 6: Deploy to Heroku After completing the major legwork, we only need to take a few simple steps to deploy our application to Heroku. Create the file with Python dependencies requirements.txt Heroku will need to know what Python dependencies to install when building our project. It looks for this list in a file called . We can easily generate one with this command: requirements.txt (venv) ~/project$ pip freeze > requirements.txt Create the Procfile We also need to tell Heroku how to spin up our Python application. We do this in a file called . Procfile (venv) ~/project$ echo \
   'web: uvicorn index:app --host=0.0.0.0 --port=${PORT}' > Procfile Create the file runtime.txt Lastly, will tell Heroku which Python runtime version we would like to use. runtime.txt (venv) ~/project$ echo 'python-3.11.8' > runtime.txt Those are all the files we need. This is what our project folder structure should look like (we’ve removed the persisted vector index): ~/project$ tree
.
├── data
│   └── confessions.txt
├── index.py
├── Procfile
├── requirements.txt
└── runtime.txt

1 directory, 5 files If you’re working from scratch and didn’t clone the for this demo project, then commit these files to your own Git repository. GitHub repo Create a Heroku app After downloading and installing the , run the following commands. You can choose any name for your app, and you’ll need to provide your unique OpenAI API key. Heroku CLI ~/project$ heroku login

~/project$ heroku apps:create my-llamaindex-app

~/project$ heroku git:remote -a my-llamaindex-app

~/project$ heroku config:add OPENAI_API_KEY=replaceme -a my-llamaindex-app

~/project$ git push heroku main
…
remote: -----> Building on the Heroku-22 stack
remote: -----> Determining which buildpack to use for this app
remote: -----> Python app detected
remote: -----> Using Python version specified in runtime.txt
…
remote: -----> Launching...
remote:        Released v4
remote:        https://my-llamaindex-app-6b48faa3ee6a.herokuapp.com/ deployed to Heroku With our application deployed, we test by sending a curl request to our API server: $ curl -X POST \
       --header "Content-type:application/json" \
       --data '{"question":"Who is Ambrose?"}' \
       https://my-llamaindex-app-6b48faa3ee6a.herokuapp.com/prompt

"Ambrose is a significant figure in the text provided. He is being described
as a respected and happy man, known for his celibacy and his dedication to
reading and studying. He is referred to as a holy oracle and a person of
great influence and wisdom." Keep in mind that the curl call above uses the unique Heroku app URL for our deployment. Yours will be different from what is shown here. We are up and running on Heroku! Conclusion We’ve clearly seen the power of LlamaIndex and the important role it plays when building RAG apps to interact with LLMs. When we can easily add specific data sources as context for an LLM without expensive model retraining — that’s a huge win. It’s a win for companies and developers looking to take their LLM workflows a step further. Combining LlamaIndex with other LangChain toolsets is also seamless and straightforward. Building a chatbot requires only a few lines of additional code. And finally, being able to quickly and easily deploy our solution to Heroku makes our application immediately accessible without any fuss. Simple deployments like this free up developers to focus on the more complicated and important task of building their LLM-based solutions. Happy coding!

Streamlining LLM Implementation: How to Enhance Specific Business Solutions with RAG

In the vast expanse of the digital realm, data is the lifeblood that sustains, instructs, and enriches countless applications. Central to the management and efficient use of this data are databases, and among them, embedded databases have carved out a distinctive niche. An embedded database is essentially a database management system (DBMS) that is tightly integrated within an application's software. Unlike standalone databases which run on dedicated servers and cater to multiple applications, embedded databases run within the application itself, ensuring a seamless data flow with minimal setup and external dependencies. The importance of embedded databases in modern application design is multifold. Firstly, their self-contained nature means they can operate without the overhead of server maintenance, making deployment and distribution simpler. This is especially crucial for applications that need to be agile and responsive, devoid of external bottlenecks. Secondly, with data being a crucial asset, an embedded approach often brings with it enhanced security, as data doesn't have to traverse over networks or interact with external systems. Furthermore, the use cases for embedded databases span a wide spectrum. From powering local data storage on mobile apps, to being the heart of IoT devices collecting real-time metrics, and even serving as the foundational data store for large desktop software, embedded databases have proven to be versatile, efficient, and resilient. As we journey through this article, we'll delve deeper into three of the top embedded databases that are shaping the industry: SQLite, RocksDB, and DuckDB, uncovering what makes each of them stand out in their own right. SQLite SQLite's origins can be traced back to the early 2000s when it was conceived by D. Richard Hipp. The initial motivation wasn't to create a widely-used database, but rather to serve a specific need in a software project Hipp was working on. The aim was to develop a no-fuss, serverless, zero-configuration, and self-contained database engine, and SQLite was the result. : SQLite is publicly released as version 1.0. It stands out by virtue of its self-contained nature, where an entire relational database is stored in a single cross-platform disk file. August, 2000 : Version 2.0 was released with improved storage with a custom B-tree implementation, adding transaction capability. September, 2001 : SQLite 3, the version most widely used today, was introduced. It brought in many improvements over the previous versions, including a new file format which offers better performance and support for more SQL features. This version set the stage for SQLite's rise to ubiquity. June, 2004 SQLite is a powerhouse for developers when it comes to its SQL language capabilities. It understands most of the standard SQL language, but it does while at the same time adding a few features of its own. It provides extensive support for upsert operations via the "INSERT ON CONFLICT" clause, giving developers flexibility in handling unique constraint violations. Subqueries are also well-supported, allowing for complex nested operations within SELECT, INSERT, UPDATE, and DELETE statements. Additionally, SQLite permits the creation of user-defined functions and aggregates, granting developers the ability to tailor the SQL environment to specific needs. Furthermore, its robust set of built-in functions, from string manipulation to date-time operations, ensures that developers have a rich toolkit to perform varied transformations and computations directly within SQL queries. omit some features Over the years, SQLite's reputation as a reliable and efficient database system grew. It has been famously adopted in various applications and platforms. From web browsers like Firefox and Chrome storing bookmarks and web history, to mobile operating systems like iOS and Android powering app data storage, SQLite's footprint is vast. Today, SQLite prides itself on being the most widely deployed and used database engine. Its public domain source code, rigorous testing, and commitment to reliability have made it a staple for developers across the globe. RocksDB RocksDB, a high-performance embedded database tailored for key-value data, was birthed out of the vibrant ecosystem of open-source projects at Facebook. It is essentially an evolution, aimed at addressing the unique storage needs of the tech giant. : RocksDB was created by Dhruba Borthakur as a fork of Google's LevelDB optimized to exploit multi-core processors (CPUs), and make efficient use of fast storage, such as solid-state drives (SSD), for input/output (I/O) bound workloads. It is based on a log-structured merge-tree (LSM tree) data structure. The primary motivation behind RocksDB was to extend LevelDB's capabilities to meet the performance, efficiency, and flexibility demands of Facebook's massive real-time applications. April, 2012 : RocksDB was open-sourced by Facebook, allowing a community of developers and industries to contribute, adapt, and integrate it into their specific use cases. The decision to open-source also catalyzed a flurry of enhancements and adaptations, driven by the collective wisdom of the community. November, 2013 Over the subsequent years, RocksDB rapidly evolved. It introduced features like optimized data compaction, tunable write-ahead logs, and enhancements that provided significant performance boosts. All these were designed to cater to applications that demanded low-latency database reads and writes, especially in large-scale, real-time environments. RocksDB's design makes it adaptable beyond just key-value storage; its pluggable framework allows it to serve as a storage engine for other higher-level database systems. For example, such well known systems as Apache Flink, TiDB and YugabyteDB use RocksDB as their embedded storage engine. Today, RocksDB is recognized as a robust, high-speed storage solution that powers various products, both within and outside Facebook. From real-time analytics to search infrastructure and messaging platforms, its adaptability and performance have made it a go-to choice for many in the industry. DuckDB DuckDB stands as an intriguing testament to the evolving needs of analytical data processing in a modern context. This analytical data management system, tailored for embedded analytics, is a fairly recent entrant into the database realm but has quickly carved out its own niche. : The initial foundations of DuckDB began taking shape around this time. Unlike many other databases focused on transactional workloads, DuckDB was specifically architected to cater to analytical queries, all within an embedded context. The creators, Mark Raasveldt and Hannes Mühleisen, aimed to design a system that provided efficient analytical data processing without the need for an external system or heavy infrastructure. 2018-2019 DuckDB's design was heavily influenced by the MonetDB, a column-store database known for its efficient handling of analytical workloads. However, where MonetDB was a full-fledged server, DuckDB was intended to be lightweight and embedded. One of the standout features of DuckDB was its ability to handle vectorized query execution. This method processes data in chunks or "vectors" rather than row by row, which significantly boosts query performance, especially for analytical operations. DuckDB also garnered attention for its ease of integration. Given its embedded nature, developers could easily incorporate it into various software applications, from Python data science platforms to web-based analytics tools. : The popularity and adoption of DuckDB have been on the rise. The database system has been praised for its ability to combine the speed of analytical databases with the simplicity and low overhead of embedded systems. 2020 and beyond As of the last update, DuckDB continues to evolve, with an active community contributing towards its growth and enhancements. The database has found its place in diverse applications, from research projects to commercial platforms, attesting to its flexibility and robustness. Conclusion The landscape of embedded databases has evolved significantly over the past two decades, driven by the demands of diverse applications, from mobile apps to cutting-edge research platforms. As we've explored, SQLite, RocksDB, and DuckDB each represent a unique blend of design philosophies, optimizations, and application scenarios. Whether you're a developer seeking a lightweight storage solution or a researcher looking for efficient analytical processing, the world of embedded databases offers a myriad of options to cater to your needs. The journey, however, doesn't end here. As technology continues to advance and the data deluge grows, the evolution of embedded databases will undoubtedly march forward, ushering in new optimizations, features, and perhaps even challenges. For those keen on diving deeper into each of these powerful tools, the following resources provide comprehensive insights: offers a wealth of information on its features, use cases, and optimization tips. SQLite's official documentation For a thorough exploration of RocksDB's capabilities, Facebook's is a treasure trove of articles and updates. official RocksDB blog To delve deeper into DuckDB's design philosophy and applications, the is an excellent starting point. DuckDB project's GitHub page In closing, the realm of embedded databases, with its blend of versatility and efficiency, promises to remain a cornerstone of application development and data management in the years to come. Embracing and understanding these tools is not just beneficial - it's essential for anyone keen on staying ahead in the rapidly evolving tech landscape.

A Closer Look at the Top 3 Embedded Databases: SQLite, RocksDB, and DuckDB

Greetings from the land of sleep-deprived partners! As I sit here at my desk, yawning like a baby hippo and trying to keep my eyelids from turning into curtains, I can't help but wonder: Is there anything your genius mind can't do? I come to you today with a simple plea, a request that could reform the way we sleep and potentially save countless relationships from the clutches of nocturnal cacophony. My appeal though simple is significant: can you please, pretty please, create a noise-cancelling device specifically designed for snoring partners? You see, , I am not just an average human; I am a sleep-deprived hero trying to navigate the treacherous waters of slumber next to a snoring partner. The nightly struggle is real, and it's time we address it with your ingenious touch. Mr. Musk Imagine this Musk: a cozy bedroom, dimly lit, the scent of lavender wafting through the air, and two souls lying side by side, ready to embrace the sweet caress of dreams. But as soon as the lights go out, a racket of cosmic proportions erupts. No, it's not the sound of a rocket leaving the launchpad at SpaceX station; it's the snoring symphony composed by my significant other. Now, don't get me wrong. I love my partner to the moon and back (pun intended), but when it comes to their snoring, even the most patient among us can feel like they're orbiting the brink of insanity. I've tried earplugs, noise-cancellation headphones, and even blasting heavy metal into my eardrums (which only led to some groovy, headbanging dreams). But alas, none of these solutions are as elegant and effective as what your genius mind could concoct. Picture this device, dear Master of Innovation: sleek, comfortable, and designed to fit snugly around the ears. As soon as it detects the seismic rumblings of snoring, it springs into action. Advanced algorithms analyze the snore frequency, amplitude, and duration, while microphones pick up other environmental sounds. Then, like magic, the device generates an anti-snore sound wave, perfectly out of phase with the original snore, effectively canceling it out. Here’s a potential for marital bliss! The tranquillity of uninterrupted sleep! Partners across the globe would celebrate the advent of such a device. Countless couples would be saved from sleeping in separate rooms, escaping the tragic fate of drifting apart due to incompatible nighttime noise levels. Of course, there may be some comical mishaps along the way. But imagine the marketing possibilities, Elon! You could call it "SnoreX" or "SleepX," and it would fly off the shelves faster than your Roadster. I can already see the testimonials pouring in, praising you as the saviour of sleep-deprived relationships everywhere. I must admit, Mr. Musk, I've had my fair share of waggish encounters with snoring partners. From recording their snorts and playing them back in the morning, only to be met with disbelieving stares, to waking them up accidentally while trying to stifle their snores – it's been quite the adventure. Now, I know you're a busy man, Elon, juggling more projects than I have fingers to count them on, but I genuinely believe this snore-cancelling device could be a game-changer. It might not be as awe-inspiring as relocating humanity to Mars or exploring the cosmos, but it would be an everyday marvel, silently mending relationships and spreading happiness, one night of peaceful sleep at a time. So, dear , if you're reading this, take a moment to ponder the plight of snoring partners worldwide. Let your imagination run wild, unleash your creative brilliance, and gift us with the ultimate solution to noise pollution. Together, we can make bedtime great again! Elon With hope, humour, and a dash of sleep deprivation, A fervent supporter in need of quiet nights.

HIPPO READS

hipporeads.com

1-10 employees

Since 2012

COMPANY RANKING

HIPPO READS

EVERGREEN INDEX #5277

Representing this company? Click here to claim and customize this page!

Hippo Reads WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!

HIPPO READS

hipporeads.com

1-10 employees

Since 2012

COMPANY RANKING

HIPPO READS

EVERGREEN INDEX #5277

RELATED COMPANIESRANK

STORIES ABOUT HIPPO READS

Representing this company? Click here to claim and customize this page!

Hippo Reads WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!