DEV Community: Samuel Oladejo

Democratizing AI: Building a RAG System with Gemma and LangChain

Samuel Oladejo — Tue, 17 Jun 2025 00:17:41 +0000

Presented at DevFest 2024, Johannesburg

Artificial Intelligence is no longer the exclusive domain of massive corporations or high-end research labs. With the rise of open-source models like Gemma and modular frameworks like LangChain, it is now possible to build robust, domain-specific AI systems using publicly available tools.

At DevFest Johannesburg 2024, I walked through how to build a Retrieval-Augmented Generation (RAG) system using Gemma, LangChain, and Vertex AI — with a working chatbot demo and live deployment.

What is Retrieval-Augmented Generation (RAG)?

RAG is an AI architecture that combines:

Information retrieval (search, databases, document indexes)
Generative language models (like Gemma or Gemini)

This enables systems to access external knowledge, retrieve relevant content, and use that content to ground the generation of responses, improving both factual accuracy and relevance.

Why Use RAG?

Traditional language models are limited to what they were trained on. RAG addresses this limitation by adding real-time context from external sources. Some of the key advantages of RAG systems include:

Access to the latest information
Factual grounding and domain control
Semantic search with vector databases and relevance-based re-ranking
Enhanced response quality and trustworthiness

How It Works

RAG systems typically follow this pipeline:

1. Retrieval and Preprocessing

External documents (e.g., knowledge bases, PDFs, databases) are searched using vector similarity or keyword search.
Retrieved results are cleaned, tokenized, and filtered to prepare for use in generation.

2. Grounded Generation

Retrieved and preprocessed content is injected into the input context of the LLM.
The model then uses this grounded context to generate responses that are both accurate and contextually rich.

Core Concepts in RAG

When building a RAG system, several key processes are involved:

Chunking

Splitting large documents into smaller chunks for indexing and retrieval.

Embedding

Transforming text chunks into high-dimensional vectors using an embedding model, making them searchable by meaning.

Indexing

Storing embeddings in a vector database like PostgreSQL with pgvector for fast similarity search.

Retrieval

Searching for relevant chunks based on user input.

Grounding

Combining retrieved context with the user query to provide better background for the language model.

Generation

Using the LLM (in our case, Gemma) to generate an answer based on the grounded context.

Building with LangChain and Gemma

We built the system using the following stack:

Component	Technology
LLM	Gemma (Open-source)
Framework	LangChain + LangGraph
Storage	PostgreSQL + pgvector
UI / API	FastAPI + LangServe
Deployment	Cloud Run (Serverless)

LangChain

LangChain provides modular tools for handling each step of the RAG pipeline — from data ingestion to generation chaining.

LangGraph

LangGraph allows building orchestrated workflows and agentic behaviors, essential for more complex RAG pipelines.

LangSmith

We used LangSmith to debug, monitor, and test our RAG applications throughout development.

Live Demo: Local RAG Chatbot with Gemma and Vertex AI

During the presentation, we built a fully functional RAG chatbot that:

Accepts user queries
Searches documents using vector search
Grounds the query with retrieved chunks
Generates an answer using Gemma

Services Used

LangChain – Framework for building the RAG app
Cloud Run – Deployment of both the indexing and inference pipeline
PostgreSQL on Cloud SQL – Vector database using pgvector
FastAPI + LangServe – Simple and scalable REST API interface

Conclusion

With open models like Gemma and flexible frameworks like LangChain, building a RAG system has become far more accessible. You can now create AI applications that are not only intelligent but also grounded in real, trustworthy data — whether you're working on a chatbot, documentation assistant, or enterprise search tool.

AI is no longer locked behind proprietary walls. With the right tools and frameworks, you can build, test, and deploy contextual LLM-powered apps in a weekend.

Additional Resources

Feel free to reach out if you're building with LangChain or deploying RAG systems — always happy to connect and share ideas!

Mastering AWS Concepts: A Comprehensive Guide to Key Services and Architectures

Samuel Oladejo — Tue, 17 Jun 2025 00:16:25 +0000

AWS Essentials for Developers and Architects

AWS (Amazon Web Services) is the leading cloud computing platform that provides a wide array of services to build, deploy, and manage scalable applications. This blog takes a deep dive into some of the most critical AWS services, concepts, and architectures for developers and cloud architects, focusing on CI/CD pipelines, serverless solutions, container orchestration, monitoring, and optimization strategies.

Continuous Integration and Continuous Delivery (CI/CD) in AWS

CI/CD is pivotal for modern application development, ensuring fast, reliable, and automated code integration and deployment. AWS provides services like CodeCommit, CodeBuild, CodePipeline, and CodeDeploy to streamline CI/CD workflows.

Key CI/CD Services

CodeCommit:

A fully managed source control service for hosting secure and scalable Git repositories. Integrates with CodePipeline and tools like Jenkins.
CodeBuild:

A managed continuous integration service that compiles source code, runs tests, and produces build artifacts.
- Supports Docker for reproducible builds
- Can cache dependencies for faster builds
- Uses buildspec.yml for build configuration
- Logs and metrics monitored via CloudWatch
CodePipeline:

Automates build, test, and deployment phases. Pipelines consist of multiple stages, with artifacts typically stored in S3.
CodeDeploy:

Automates deployments to EC2, Lambda, or on-premises instances. Supports strategies:
- AllAtOnce: Fastest, but risks downtime
- Rolling Updates: Updates a few instances at a time
- Immutable: Deploys to new instances for rollback safety
- Blue/Green Deployments: Tests in a new environment before redirecting traffic

Serverless Architectures with AWS

AWS Serverless services allow developers to build and manage applications without managing infrastructure.

AWS Lambda

Executes code in response to events. Supports multiple languages and integrates with S3, DynamoDB, and API Gateway.

Provisioned Concurrency: Reduces cold start latency
Environment Variables: Runtime configuration
Event Source Mapping: Triggers from services like Kinesis, SQS

AWS SAM (Serverless Application Model)

Simplifies serverless development using templates.

AWS::Serverless::Function: Defines Lambda functions
AWS::Serverless::Api: Manages API Gateway
AWS::Serverless::SimpleTable: Creates DynamoDB tables

API Gateway

Manages REST, HTTP, and WebSocket APIs.

Integrates with Lambda
Supports usage plans and response caching

Container Orchestration with ECS and EKS

AWS supports containerized workloads through ECS and EKS.

Elastic Container Service (ECS)

Fully managed container orchestration:

EC2 Launch Type: Containers on EC2
Fargate Launch Type: Serverless containers
Task Definitions: JSON specs with container config
Service Auto Scaling: Scales tasks based on traffic

Elastic Kubernetes Service (EKS)

Managed Kubernetes service for deploying containers.

Node Types: Managed, self-managed, or Fargate
Cluster Scaling: Uses Auto Scaling Groups

Storage Solutions in AWS

AWS provides diverse storage services for various use cases.

Amazon Elastic File System (EFS)

Managed file system with auto-scaling and multi-AZ support. Ideal for EC2 or container data sharing.

Amazon S3

Scalable object storage with features like:

Bucket Policies: Access control
CORS Configuration: Cross-origin API requests
S3 Object Ownership: Ensures consistent ownership across accounts

Relational and NoSQL Databases

Amazon RDS

Managed relational database supporting MySQL, PostgreSQL, MariaDB.

Read Replicas: Improve read performance
Multi-AZ Deployment: High availability and failover
RDS Proxy: Better connection pooling, faster failovers

DynamoDB

Serverless NoSQL database.

Global Secondary Index (GSI): Alternative query keys
Transactions: Atomic operations
On-Demand Mode: Auto-scales with traffic

Monitoring and Optimization

Monitoring ensures application health and efficient resource usage. AWS offers CloudWatch, X-Ray, and CloudTrail.

CloudWatch

Collects metrics, logs, and events.

Custom Metrics: Via PutMetricData API
Alarms: Trigger actions on thresholds
Synthetics: API and endpoint monitoring via scripts

AWS X-Ray

Distributed tracing tool.

Visualizes latency, errors, dependencies
Annotates traces with metadata for debugging

CloudTrail

Logs API activity for governance and compliance.

Management Events: Track configurations
Data Events: Monitor S3 access, Lambda invocations
CloudTrail Insights: Detect anomalies

Messaging and Integration

AWS provides messaging tools to decouple and coordinate microservices.

Amazon SQS

Managed message queue.

Standard Queues: High throughput, at-least-once delivery
FIFO Queues: Ordered, exactly-once delivery
Dead Letter Queues (DLQ): Isolate failed messages
Long Polling: Reduce costs, fewer empty responses

Amazon SNS

Publish-subscribe messaging.

Topic Subscriptions: Fan-out to endpoints
Message Filtering: Targeted message delivery

Amazon Kinesis

Processes real-time data streams.

Kinesis Data Streams: Large-scale data ingestion
Kinesis Firehose: Delivers to S3, Redshift, etc.
Kinesis Data Analytics: SQL-based real-time processing

Infrastructure as Code with CloudFormation

CloudFormation enables declarative AWS resource management.

Templates: YAML/JSON definitions
Parameters/Mappings: Dynamic configurations
Outputs: Share values across stacks
Nested Stacks: Modular design

Best Practices and Tips

Use Provisioned Concurrency for critical Lambda functions
Enable X-Ray Sampling to balance cost and visibility
Configure Dead Letter Queues for SQS and Lambda
Use CloudFormation Drift Detection to spot changes
Leverage IAM Access Analyzer for policy reviews

Conclusion

AWS offers a comprehensive set of services for building scalable, secure, and reliable applications. From CI/CD pipelines to serverless architectures, container orchestration, and robust monitoring, AWS simplifies cloud-native development. Mastering these tools and patterns empowers developers and architects to meet modern application demands.