Tourial

tourial

Interest attaching to this Planet

After reading the title, you are probably wondering what a microservice is and what makes it different from a monolith Java program. If we look into the definition of microservices. Basically, a microservice is an architecture. Microservices (or microservices architecture) are a cloud-native architectural approach in which a single application is composed of many loosely coupled and independently deployable smaller components, or services So why microservices rather than using monolith programs? — The key principle of microservices is simplicity. Applications become easier to build and maintain when they’re split into a set of smaller, composable fragments. Managing the code also becomes less painful because each microservice is, in fact, a separate chunk of code. Services can be implemented using different programming languages, databases and software environments. This allows each service to be deployed, rebuilt, re-deployed and managed independently. Easier to Build and Maintain Apps Because of microservices, each developing team can only look at the specific service they are building without worrying about the whole source code. This will increase the productivity of the team with the delivery speed. Improved Productivity and Speed — As demand for an app increases, it’s easier to scale using microservices. You can increase resources to the most needed microservices rather than scaling an entire app. This also means scaling is faster and often more cost-efficient as well. Microservices are independently scalable — If a specific microservice fails, you can isolate that failure to that single service and prevent cascading failures that would cause the app to crash. This fault isolation means that your critical application can stay up and running even when one of its modules fails. Microservices reduce downtime through fault isolation — So now we know why normally all the big organizations prefer microservices rather than maintaining a big combined source code. Let's try to develop a microservice using Spring Boot, which is a very popular Java framework which uses to develop enterprise applications. Project Description What we are going to develop is a microservice to create RESTful APIs for Tour Application in California 🗻. Let’s get started, Create Project In the Spring ecosystem, there are a lot of dependencies you can find. For this, we are going to need dependencies for Web, which includes Tomcat and Spring MVC Rest repositories to expose Spring Data repositories over REST APIs Java Persistence API H2 in-memory database You can easily create a Spring project by using Go to the spring initializer web page and select project as a Maven project, for language select Java, fill the project metadata, select packaging as JAR and select the Java version you are developing. Then add the dependencies, . Spring Initializer Spring MVC REST Repositories Spring Data JPA H2 Database And finally, click generate, it will download a zip file that created your project structure with the pointed dependencies in your file. pom.xml Project Structure As you can see in the above picture there are a few files and if we check the file we can see the dependencies which we added in the Spring initializer is presented here. pom.xml Let's look at the file. CaliforniaApplication.java https://gist.github.com/maneeshaindrachapa/f0d9fc4cb4c06216abc94a0d8885731c This file has a method and also there is annotation. Adding this annotation means that we tell the JVM to this is where the microservice is starting and the method is there so it is not like packaged war files so we can actually control the web application start and stop. CaliforniaApplication.java main @SpringBootApplication main @SpringBootApplication annotation is used to mark a configuration class that declares one or more @Bean methods and also triggers auto-configuration and component scanning. It’s the same as declaring a class with @Configuration, @EnableAutoConfiguration and @ComponentScan annotations. Starting Spring Boot Server When you run the main method you can see that the Spring application is starting. To change the port that the server is starting you can go to the file and add a new property application.properties server.port=8081 To check the server is working go to and you can see something like below, http://localhost:8081/profile Developing the Project Now we are ready to develop the Tour California restful web service. First, let's check the class diagram of the restful web service we are going to build 1. Create Models First, create a new package and name it as a , and create these business objects in there. model https://gist.github.com/maneeshaindrachapa/58ec8c3924b2044dcc0468e1026cb429 https://gist.github.com/maneeshaindrachapa/dab4d0be4308ff21d545c33188ce8119 https://gist.github.com/maneeshaindrachapa/9c1c7570931c43dd781d30f2d184348d https://gist.github.com/maneeshaindrachapa/64ad22989db443dc1996881cff5e5249 As you can see in the and files, there are some annotations that have been used. Let's look at what they mean. These annotations are used in Java Persistent API. As a specification; Tour.java TourPackage.java the Java Persistence API is concerned with persistence, which loosely means any mechanism by which Java objects outlive the application process that created them. Annotate all your entity beans with @Entity. @Entity — — Specify the column mapping using @Column annotation. @Column — Annotate the id column using @Id. @Id — Let the database generate (auto-increment) the id column. @GeneratedValue For entities sharing the same primary key, we can associate them using @OneToOne. @OneToOne — For entities that have many relationships with one entity, as an example, in our project, one TourPacakge consists of many Tours. @ManyToOne — — This way, we can instruct a JPA provider to convert an enum to its ordinal or String value. @Enumerated 2. Create Repositories Create a new package name and create the repositories need for the project repository https://gist.github.com/maneeshaindrachapa/7cff46d5fa9eb49330c7f5a99947d2ab https://gist.github.com/maneeshaindrachapa/638b0cf86a76bf4ed18958c202eb5ae0 interface which is a Spring Data interface for generic CRUD operations on a repository of a specific type. It provides several methods out of the box for interacting with a database. When extending you need to define We are creating repositories for the two entities we have and also we are extending the CrudRepository CrudRepository<T, ID> T-entity, ID-the type of your ID column in Entity . In the above code, some annotations were used. Let’s see what are they, used to set options on the public Repository interface — it will automatically create endpoints as appropriate based on the type of Repository that is being extended (CrudRepository/PagingAndSortingRepository/etc) @RepositoryRestResource — specialization of annotation which is used to indicate that the class provides the mechanism for storage, retrieval, update, delete and search operation on objects. @Repository — @Component 3. Create Services Create a new package name and create the services need for the project in there. service https://gist.github.com/maneeshaindrachapa/61ca2e4a380135eff34e9ab261c5b5a8 https://gist.github.com/maneeshaindrachapa/f6e61d5623268fd12d1b90e68714111e In the above code, some annotations were used. Let’s see what are they, — this is . Spring context will autodetect these classes when annotation-based configuration and classpath scanning is used. @Service used with classes that provide some business functionalities — this annotation provides more fine-grained control over where and how autowiring should be accomplished. The annotation can be used to autowire bean on the setter method just like annotation, constructor, a property, or methods with arbitrary names and/or multiple arguments. @Autowired @Autowired @Required As you can see in the above code we are using the repository interfaces we created before this to use the methods already developed in the interface such as . Basically, we use services to mask out the repositories from the external parties and use the logic that we want in the . CrudRepository findById(),findAll() business layer 4. Database SetUp In our project to see that the APIs are working we need to have some data in our database. Here we are using the h2 in-memory database. So let’s first add some configurations to where we can access the in-memory database. application.properties spring.h2.console.enabled=true
spring.datasource.url=jdbc:h2:mem:tourcalifornia
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=admin
spring.datasource.password=admin
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect

spring.jpa.hibernate.ddl-auto=create-drop Now from where the main method has, we can implement the interface which is a simple Spring Boot interface with a run method. Spring Boot will automatically call the run method of all beans implementing this interface after the application context has been loaded. CaliforniaApplication.java CommandLineRunner First, we add a property to our file to read the file application.properties ExploreCalifornia.json ec.importfile=ExploreCalifornia.json And then we add some code to read the JSON file and add them to the database in file. We can use @value in spring to import the file name. CaliforniaApplication.java — this annotation provides a convenient way to inject property values into components. It’s also quite useful to provide sensible defaults for cases where a property may not be present @Value https://gist.github.com/maneeshaindrachapa/eefdf5333c6607eff93ae7e6be82e2a9 And we need to add a new method for the file because we use TourPackageRepository.java TourPackage tourPackage = tourPackageRepository.findByName(tourPackageName).orElseThrow(() ->
        new RuntimeException("Tour package does not exist: " + tourPackageName)); So let’s add the to file. Optional<TourPackage> findByName(String, name); TourPackageRepository.java https://gist.github.com/maneeshaindrachapa/f50f664fdd163d1d85694d866d40a68d Let’s restart the server and go to the URL where the h2 database console is. http://localhost:8081/h2-console/ Then add the username, password, JDBC URL you configured in and log in to the h2 console. To see that the data populated to the tables can run a simple query such as application.properties SELECT * from TOUR; Or we can actually go to the in browser and see the data(Because we add in our repositories we can run GET/POST/PUT/DELETE commands in our repositories). http://localhost:8081/tours/ @RepositoryRestResource if you don’t want the data exposed like this, you need to add in your repositories. @RepositoryRestResource(exported = false) 5. Creating Controllers Create a new package name and create the controllers that need for the project in there. controller https://gist.github.com/maneeshaindrachapa/33b9175a896a064c92b9242ff32d7f9c In the above code, some annotations were used. Let’s see what are they, @RestController — The @RestController combines @Controller and @ResponseBody @RequestBody — which maps the body of the HTTP request to an object. @PathVariable — This annotation indicates that a method argument is bound to a URI template variable. @RequestParam — this annotation is used for accessing HTTP request parameters @PostMapping— The @PostMapping annotated methods in the @Controller annotated classes handle the HTTP POST requests matched with the given URI expression @GetMapping — The @GetMapping annotated methods in the @Controller annotated classes handle the HTTP GET requests matched with the given URI expression @PutMapping — The @PutMapping annotated methods in the @Controller annotated classes handle the HTTP PUT requests matched with the given URI expression @DeleteMapping — The @DeleteMapping annotated methods in the @Controller annotated classes handle the HTTP DELETE requests matched with the given URI expression @PatchMapping — The @PatchMapping annotated methods in the @Controller annotated classes handle the HTTP PATCH requests matched with the given URI expression @ExceptionHandler — using this annotation we can declare a custom error handler method. Spring calls this method when a request handler method throws any of the specified exceptions. @ResponseStatus — using this annotation we can specify the desired HTTP status of the response if we annotate a request handler method with this annotation. We can declare the status code with the code argument, or it's an alias, the value argument @RequestMapping — this annotation marks request handler methods inside @Controller classes; it can be configured using, path, or its aliases, name, and value: which URL the method is mapped to method: compatible HTTP methods params: filters requests based on presence, absence, or value of HTTP parameters headers: filters requests based on presence, absence, or value of HTTP headers consumes: which media types the method can consume in the HTTP request body produces: which media types the method can produce in the HTTP response body 6. Testing the APIs To test the APIs we can use the . You can get the postman collection from . Postman here You can find the full code . here So this is it. This is how you develop a microservice using Spring Boot. This is only a small bit of the Spring ecosystem. Let's look at how to secure APIs and what are the next steps we can do with springs in another blog post. First Published here

Monolith to Microservices: Build Your First Microservice App With Spring Boot

Like many students, I do not enjoy scrolling through endless PDFs. I would if I could skip reading and just ask my textbook questions. So, naturally, I did what any lazy-but-resourceful person would do: I dumped the entire PDF into an LLM and started asking questions, praying to God that the answers were accurate. do not Spoiler alert: they weren’t. The answers were either vague, wrong, or just plain confusing. That’s when I realized — large language models aren’t magic (shocking, I know). They have context limits, and stuffing a whole book into one prompt is like trying to fit a watermelon into a ziplock bag. context limits So I started digging, and that’s when I found the real MVP: RAG (Retrieval-Augmented Generation). With RAG, instead of force-feeding the model everything, you teach it where to look — and suddenly, answers start making sense RAG (Retrieval-Augmented Generation) where Why Large Context Windows Don’t Really Help (Much) Why Large Context Windows Don’t Really Help (Much) You might think, “Wait… but newer models have massive context windows, right? Shouldn’t that fix the problem?” In theory? Yes. In practice? Meh. Even with context windows stretching up to 100k tokens (which sounds huge), you're still working with trade-offs: They’re expensive to use.


They often truncate or compress information.


And unless your prompt is perfectly structured (which is rarely the case), the model still ends up hallucinating or giving generic responses. They’re expensive to use. They’re expensive to use. They often truncate or compress information. They often truncate or compress information. And unless your prompt is perfectly structured (which is rarely the case), the model still ends up hallucinating or giving generic responses. And unless your prompt is perfectly structured (which is rarely the case), the model still ends up hallucinating or giving generic responses. It’s like asking your friend to remember every word of a 300-page book and hoping they don’t mess up the details. Not ideal. RAG to the Rescue RAG to the Rescue RAG — Retrieval-Augmented Generation — is like giving your LLM a cheat sheet… but a really smart, targeted one. RAG — Retrieval-Augmented Generation — is like giving your LLM a cheat sheet… but a really smart, targeted one. Here’s the flow: Here’s the flow: You split your book into smaller chunks
You store these chunks in a vector DB.
When a user asks a question, you don’t give the model the entire book — just the most relevant parts.
Then the LLM crafts a solid, informed answer using onlythose parts. You split your book into smaller chunks You store these chunks in a vector DB. When a user asks a question, you don’t give the model the entire book — just the most relevant parts. entire most relevant parts Then the LLM crafts a solid, informed answer using onlythose parts. only Less noise. More signal. Way better answers. What Does the RAG Pipeline Look Like? What Does the RAG Pipeline Look Like? Imagine you’re the middleman between your textbook and your model. Your job is to: Your job is to: Split the content → Break the book into readable chunks


Convert them into vectors → Using an embedding model (Cohere)


Save those vectors → In a vector database (Pinecone)


When a question is asked:

Convert the question into a vector
Search the database for chunks that are most similar (using cosine distance metric)
Send the best matches + the question to a language model (I used Gemini)
Boom — you get a clear, helpful answer Split the content → Break the book into readable chunks Split the content → Break the book into readable chunks Convert them into vectors → Using an embedding model (Cohere) Convert them into vectors → Using an embedding model (Cohere) Save those vectors → In a vector database (Pinecone) Save those vectors → In a vector database (Pinecone) When a question is asked:

Convert the question into a vector
Search the database for chunks that are most similar (using cosine distance metric)
Send the best matches + the question to a language model (I used Gemini)
Boom — you get a clear, helpful answer When a question is asked: Convert the question into a vector
Search the database for chunks that are most similar (using cosine distance metric)
Send the best matches + the question to a language model (I used Gemini)
Boom — you get a clear, helpful answer Convert the question into a vector Search the database for chunks that are most similar (using cosine distance metric) Send the best matches + the question to a language model (I used Gemini) Boom — you get a clear, helpful answer And that’s the heart of it. You’re not replacing the model’s brain — just giving it better memory. My Stack: Simple, Powerful, Beginner-Friendly My Stack: Simple, Powerful, Beginner-Friendly Here’s what I used: 🧠 Cohere – To turn both book content and questions into vectors (aka embeddings)
📦 Pinecone – To store and search those vectors super efficiently
💬 Gemini – To generate the final, natural-language response 🧠 Cohere – To turn both book content and questions into vectors (aka embeddings) 🧠 Cohere – 📦 Pinecone – To store and search those vectors super efficiently 📦 Pinecone – 💬 Gemini – To generate the final, natural-language response 💬 Gemini – You don’t have to use these, but this combo is beginner-friendly, well-documented, and plays nicely together. have Step-by-Step: Build Your Own AskMyBook Bot Step-by-Step: Build Your Own AskMyBook Bot Okay, let’s actually build the thing now. I used Google Colab (because free GPU and easy sharing), but this should work in any Python environment. Okay, let’s actually build the thing now. I used Google Colab (because free GPU and easy sharing), but this should work in any Python environment. Step 1: Load and Chunk Your Book Step 1: Load and Chunk Your Book I used the PyMuPDF library to extract text. I used the PyMuPDF library to extract text. !pip install pymupdf !pip install pymupdf Now, let’s extract the text: Now, let’s extract the text: import fitz  # PyMuPDF

def extract_text_from_pdf(pdf_path):

    doc = fitz.open(pdf_path)

    text = ""

    for page in doc:

        text += page.get_text()

    return text 

book_path = 'enter the path here'

book_text = extract_text_from_pdf(book_path) import fitz  # PyMuPDF

def extract_text_from_pdf(pdf_path):

    doc = fitz.open(pdf_path)

    text = ""

    for page in doc:

        text += page.get_text()

    return text 

book_path = 'enter the path here'

book_text = extract_text_from_pdf(book_path) Now, we’ll split the book into chunks, making it more digestible. import re

def chunk_text(text, chunk_size=300, overlap=50):

    words = re.findall(r'\S+', text)

    chunks = []

    for i in range(0, len(words), chunk_size - overlap):

        chunk = ' '.join(words[i:i + chunk_size])

        chunks.append(chunk)

    return chunks

chunks = chunk_text(book_text)

print(f"Total Chunks: {len(chunks)}")

print("Sample chunk:\n", chunks[0]) import re

def chunk_text(text, chunk_size=300, overlap=50):

    words = re.findall(r'\S+', text)

    chunks = []

    for i in range(0, len(words), chunk_size - overlap):

        chunk = ' '.join(words[i:i + chunk_size])

        chunks.append(chunk)

    return chunks

chunks = chunk_text(book_text)

print(f"Total Chunks: {len(chunks)}")

print("Sample chunk:\n", chunks[0]) Here, each chunk has 300 words, with a 50-word overlap for context continuity. Think of it as giving the model a smooth flow between paragraphs. Step 2: Create Embeddings with Cohere Embeddings = turning text into numbers that reflect meaning. We’ll use Cohere's embed-english-v3.0 model for this. !pip install cohere

import cohere

co = cohere.Client("YOUR-API-KEY")  # Replace with your actual key

def get_embeddings(texts):

    response = co.embed(

        texts=texts,

        model="embed-english-v3.0",

        input_type="search_document"

    )

    return response.embeddings !pip install cohere

import cohere

co = cohere.Client("YOUR-API-KEY")  # Replace with your actual key

def get_embeddings(texts):

    response = co.embed(

        texts=texts,

        model="embed-english-v3.0",

        input_type="search_document"

    )

    return response.embeddings Step 3: Store Chunks in Pinecone Now we store the embeddings in Pinecone — a vector database that helps us search similar chunks later. !pip install pinecone

import pinecone

pinecone = pinecone.Pinecone(api_key="YOUR-API-KEY")

index_name = "ask-my-book"

if index_name not in pinecone.list_indexes().names():

    pinecone.create_index(

        index_name,

        spec={

            "pod": {

                "pod_type": "p1",

                "replicas": 1,

                "metric": "cosine",

                "environment": "aws-us-east1"

            }

        },

        dimension=1024

    )

index = pinecone.Index(index_name) !pip install pinecone

import pinecone

pinecone = pinecone.Pinecone(api_key="YOUR-API-KEY")

index_name = "ask-my-book"

if index_name not in pinecone.list_indexes().names():

    pinecone.create_index(

        index_name,

        spec={

            "pod": {

                "pod_type": "p1",

                "replicas": 1,

                "metric": "cosine",

                "environment": "aws-us-east1"

            }

        },

        dimension=1024

    )

index = pinecone.Index(index_name) Now, batch upload the chunks import uuid

import time

batch_size = 96 

for i in range(0, len(chunks), batch_size):

    batch_chunks = chunks[i:i+batch_size]

    batch_embeds = get_embeddings(batch_chunks)

    ids = [str(uuid.uuid4()) for _ in batch_chunks]

    vectors = list(zip(ids, batch_embeds, [{"text": t} for t in batch_chunks]))

    index.upsert(vectors=vectors)

    time.sleep(60)  # avoid hitting rate limits import uuid

import time

batch_size = 96 

for i in range(0, len(chunks), batch_size):

    batch_chunks = chunks[i:i+batch_size]

    batch_embeds = get_embeddings(batch_chunks)

    ids = [str(uuid.uuid4()) for _ in batch_chunks]

    vectors = list(zip(ids, batch_embeds, [{"text": t} for t in batch_chunks]))

    index.upsert(vectors=vectors)

    time.sleep(60)  # avoid hitting rate limits Boom! Your book is now smartly stored in vector format. Step 4: Ask Questions + Get Answers with Gemini We’ll search for relevant chunks using your query, and then pass those to Gemini for generating an answer. First, get the query embedding: def get_query_embedding(query):

    response = co.embed(

        texts=[query],

        model="embed-english-v3.0",

        input_type="search_query"

    )

    return response.embeddings[0] def get_query_embedding(query):

    response = co.embed(

        texts=[query],

        model="embed-english-v3.0",

        input_type="search_query"

    )

    return response.embeddings[0] Now, search Pinecone: def search_similar_chunks(query, top_k=5):

    query_embedding = get_query_embedding(query)

    result = index.query(vector=query_embedding, top_k=top_k, include_metadata=True)

    return [match['metadata']['text'] for match in result['matches']] def search_similar_chunks(query, top_k=5):

    query_embedding = get_query_embedding(query)

    result = index.query(vector=query_embedding, top_k=top_k, include_metadata=True)

    return [match['metadata']['text'] for match in result['matches']] Then plug the top chunks into Gemini: import google.generativeai as genai

genai.configure(api_key="YOUR-GEMINI-API-KEY")

model = genai.GenerativeModel("gemini-1.5-flash")

def generate_answer(query):

    context_chunks = search_similar_chunks(query)

    context = "\n\n".join(context_chunks)

    prompt = f"""

You are an assistant bot trained on the following book content. Use only the info provided to answer the user's question.

Book Context:

{context}

Question:

{query}

If the question is not relevant to the context, respond with:

'I am a bot trained to answer questions based on the book content. This question is out of scope.'

"""

    response = model.generate_content(prompt)

    return response.text import google.generativeai as genai

genai.configure(api_key="YOUR-GEMINI-API-KEY")

model = genai.GenerativeModel("gemini-1.5-flash")

def generate_answer(query):

    context_chunks = search_similar_chunks(query)

    context = "\n\n".join(context_chunks)

    prompt = f"""

You are an assistant bot trained on the following book content. Use only the info provided to answer the user's question.

Book Context:

{context}

Question:

{query}

If the question is not relevant to the context, respond with:

'I am a bot trained to answer questions based on the book content. This question is out of scope.'

"""

    response = model.generate_content(prompt)

    return response.text Try it out! question = "What’s does the author say in Module 1 of the book?"

print(generate_answer(question)) question = "What’s does the author say in Module 1 of the book?"

print(generate_answer(question)) That’s It — You Now Have an Ask-My-Book Bot! You built a bot that: Understands your textbook
Finds the right part when asked
Gives meaningful answers using that part only Understands your textbook Finds the right part when asked Gives meaningful answers using that part only No more endless skimming. Just type and ask. What Next? Level Up Your Book-Bot What we’ve built is a basic but powerful Question-and-Answer system. Think of it as the MVP (Minimum Viable Product) of your personal study assistant. But once you’re comfortable, there’s so much more you can add: Citations – Show which chunk or page the answer came from, so you can verify the source.
Multi-turn Conversations – Let the bot remember previous questions and give more intelligent answers over time.
Multi-step Reasoning – Chain thoughts together to answer complex questions.
Custom Memory – Let your bot hold on to important facts you highlight for future queries.
UI Upgrade – Hook this into a Streamlit or React frontend for a polished, user-friendly experience. Citations – Show which chunk or page the answer came from, so you can verify the source. Multi-turn Conversations – Let the bot remember previous questions and give more intelligent answers over time. Multi-step Reasoning – Chain thoughts together to answer complex questions. Custom Memory – Let your bot hold on to important facts you highlight for future queries. UI Upgrade – Hook this into a Streamlit or React frontend for a polished, user-friendly experience. With these, your bot goes from “smart textbook” to “AI study buddy.” If you’ve ever stared at a textbook, praying it would just talk back and tell you what matters — well, now it can. talk back This was my little experiment in turning boring PDFs into interactive conversations. Hope it inspires you to build your own and maybe even customize it for friends or classes. Got stuck somewhere? Want help with adding a UI or citations next? Drop a comment or ping me — always happy to chat.

Stories, News & Mentions about TOURIAL

Categories

Trending Topics

Stories, News & Mentions about TOURIAL

Tourial’s Stories on HackerNoon

Categories

Trending Topics