PostgreSQL is one of the most powerful, stable, and open-source relational database systems trusted by global giants like Apple, Instagram, and Spotify. Whether you’re building a web application, managing enterprise data, or diving into analytics, understanding PostgreSQL is a skill that sets you apart.

But what if you could master it in just 10 days, in Tamil, with hands-on learning and a guaranteed 5★ rating on HackerRank as your goal?

Sounds exciting? Let’s dive in.

Why This Bootcamp?

This 10-day PostgreSQL Bootcamp in Tamil is designed to take you from absolute beginner to confident practitioner, with a curriculum built around real-world use cases, performance optimization, and daily challenge-driven learning.

Whether you’re a

• Student trying to get into backend development
• Developer wanting to upskill and crack interviews
• Data analyst exploring SQL performance
• Tech enthusiast curious about databases

…this bootcamp gives you the structured path you need.

What You’ll Learn

Over 10 days, we’ll cover

• PostgreSQL installation & setup
• PostgreSQL architecture and internals
• Writing efficient SQL queries with proper formatting
• Joins, CTEs, subqueries, and advanced querying
• Indexing, query plans, and performance tuning
• Transactions, isolation levels, and locking mechanisms
• Schema design for real-world applications
• Debugging techniques, tips, and best practices
• Daily HackerRank challenges to track your progress
• Solve 40+ HackerRank SQL challenges

Bootcamp Highlights

• Language of instruction: Tamil
• Format: Online, live and interactive
• Daily live sessions with Q&A
• Practice-oriented learning using HackerRank
• Notes, cheat sheets, and shared resources
• Access to community support and mentorship
• Learn through real-world datasets and scenarios

Check our previous Postgres session

Details at a Glance

• Duration: 10 Days
• Language: Tamil
• Format: Online, hands-on
• Book Your Slot: https://topmate.io/parottasalna/1558376
• Goal: Earn 5★ in PostgreSQL on HackerRank
• Suitable for: Students, developers, DBAs, and tech enthusiasts

Why You Shouldn’t Miss This

• Learn one of the most in-demand database systems in your native language
• Structured learning path with practical tasks and daily targets
• Build confidence to work on real projects and solve SQL challenges
• Lifetime value from one affordable investment.

Will meet you in session !!!

Hi guys 👋

Today, I want to share something unexpected. To be honest, if someone had told me a month ago that I could do this, I wouldn’t have believed them. But here we are — I’ve finally released a Python package and dataset called TamilKavi. I still can’t believe I pulled it off, but it’s real!

I’d love to share the whole story with you. Many of you already know me — I write Tamil poetry and have even published two books. However, I faced font issues when trying to release them on Amazon and Kindle. Frustrated, I reached out to my community friend, Hari, and I asked them:
“Bro, I want to release my Tamil poetry book on Amazon, but I’m stuck with font issues. Do you know anyone who can solve it?”

Hari referred me to Ayyanar Bro, and to me it’s a surprise, he was from Madurai — what a coincidence! We spoke almost four times a week for different reasons. I had already written about him and his portfolio website, which he built using Emacs & Org, so I won’t go into more details — you guys might find it repetitive.

Through Ayyanar Bro, I learned about the Tamil Kanchilung community and FreeTamilBooks, where I finally found a solution to my font issue. But here’s another twist — FreeTamilBooks required more poetry for my book release. Because I like to release that in FreeTamilBooks.Then another book on Amazon. That was another headache because, with my tight schedule, I barely had time to write.

While navigating all this, I discovered Tamilrulepy, a Python package with Tamil grammar rules. I was eager to learn more, and unexpectedly, I got an opportunity to contribute to it! That’s when I met Boopalan — another passionate tech enthusiast like me. He helped me write code for TamilRulePy and even invited me to contribute to TamilString, a Python package for documentation. I accepted his invitation and started working on it.

Then, during one of our conversations, I got an idea: why not develop my own Python package? And that’s how TamilKavi was born.

I shared my idea with Boopalan and invited him to build it as a team because, honestly, I’m no expert. But it wasn’t easy — we had to overcome countless challenges, especially since we were both preparing for our model exams and semester exams (he’s an MSc student, and I’m a BSc student). It was a tough time, but I didn’t give up. I studied, understood, and gradually started coding — not entirely on my own, of course.

Now, you might wonder — why build a website? Simple: to collect data from authors. But due to financial constraints, the data collected through the website idea transformed into a Google Form, and now it is a navigation button. It’s another story altogether. Since I had no time, I built a basic structure using Lovable.dev and handed it over to my juniors, Gagan & Rohith, who took care of the website.

The final result? Release of the Python package & website!

I must especially thank Praveen Bro — my community brother and mentor. Without hesitation, he offered me a subdomain. For me, that’s a huge deal, and I’m incredibly grateful!

“Okay thambi, enough of this English talk — why did you release the dataset?” When you ask me likewise.

Well, there’s a reason for that, too. I’ve seen Selvakumar Duraipandian Bro on LinkedIn about their post of numerous Tamil datasets on Hugging Face, including Thirukkural, Tholkappiyam, and more. I was truly inspired by his work. So, I release that as a Dataset.

Now, you might ask, “So, thambi, after all this talk, what does your package actually do?”

It’s simple — TamilKavi helps discover new Tamil poems. That’s all. Now your mind is

“Edhuka evalo seenu?”

Well, I’m not just a developer. The person who is are Tamil poet & tech enthusiast, it’s a crazy project. Through this journey, I’ve learned so much, especially about GitHub workflows.

When you feel this content is valuable, follow me for more upcoming Blogs.

Connect with Me:

• LinkedIn: Anand Sundaramoorthy
• Instagram: @anandsundaramoorthysa
• Email: sanand03072005@gmail.com

Introduction

As artificial intelligence advances, there is growing interest in evaluating how different AI models perform in specialized domains like clinical trial statistics. This article compares two state-of-the-art large language models — Llama 4 Scout Reasoning and Claude 3.7 — on their ability to solve common statistical problems in clinical trials. It’s important to emphasize that this study examines only a limited set of three clinical trial problems and should not be interpreted as a comprehensive assessment of these models’ overall capabilities.

Llama 4 Scout Instruct Model

Claude 3.7

Problem Selection

Three foundational clinical trial statistical problems were selected to evaluate the models:

Treatment Effect Analysis: Calculating response rates, absolute risk reduction (ARR), and number needed to treat (NNT) in a cancer treatment study comparing experimental and control arms

Non-inferiority Trial Design: Determining the minimum cure rate required for a new antibiotic to be considered non-inferior to the standard of care

Interim Analysis Decision-Making: Applying O’Brien-Fleming boundaries to decide whether to stop a trial early based on interim results

Evaluation Criteria

The outputs from both models were compared across several dimensions:

• Mathematical accuracy
• Statistical reasoning approach
• Clarity of explanation
• Contextual understanding
• Presentation format
• Result interpretation

Detailed Findings

Mathematical Precision

Both models demonstrated excellent mathematical precision, arriving at identical numerical answers for all three problems:

• In Problem 1, both correctly calculated the response rates (55.6% vs 44.4%), ARR (11.2%), and NNT (9)
• In Problem 2, both determined the minimum acceptable cure rate to be 70%
• In Problem 3, both correctly concluded that the trial should not be stopped based on the interim analysis

Approach to Statistical Reasoning

Llama 4 Scout Reasoning

Llama 4 Scout approached problems with a highly structured methodology:

• Began by clearly organizing given information in bulleted lists
• Used explicit section headings to demarcate reasoning steps
• Provided direct formula applications with clear variable substitutions
• Included practical interpretations of the final statistical outcomes

Claude 3.7

Claude 3.7 demonstrated a more narrative reasoning style:

• Used numbered steps with detailed explanations before formula application
• Provided more extensive context about the statistical principles being applied
• Explained the reasoning behind formula selection
• Included additional interpretation of why certain approaches were appropriate

Explanation Quality

The models differed somewhat in their explanatory approaches:

Llama 4 Scout Reasoning

• Provided concise but complete explanations
• Excellent at clarifying practical implications (e.g., “This means we would need to treat 9 patients with the experimental treatment instead of the control treatment to achieve one additional response”)
• Included additional context about threshold interpretations

• Explicit about Type I error control in the interim analysis problem

  Claude 3.7

• Offered more detailed contextual explanations of statistical concepts

• Provided more extensive rationale for calculation approaches

• Explained why certain statistical formulas were appropriate in each context

• Included more discussion of underlying statistical principles (e.g., family-wise error rate)

Visual Presentation

The models showed distinct presentation styles:

Llama 4 Scout Reasoning

• More visually structured with effective use of bulleted lists
• Clear section labeling and organization
• Highlighted key information more prominently
• More consistent formatting throughout responses

Claude 3.7

• More narrative in style with detailed steps
• Used numbered steps with explanatory headings
• Integrated formulas within explanatory text
• Maintained professional presentation but with less visual structuring

Discussion

Complementary Strengths
This comparative analysis revealed that both models possess strong capabilities in clinical trial statistical reasoning but with slightly different emphases:

• Llama 4 Scout Reasoning excelled in structural organization, practical interpretation, and concise presentation of statistical concepts
• Claude 3.7 demonstrated particular strength in contextual explanation, statistical rationale, and discussion of underlying principles.

Practical Implications

For professionals working in clinical trial statistics, the choice between these models might depend on specific needs:

• For quick statistical calculations with a clear structure: Llama 4 Scout Reasoning’s concise and well-organized approach might be preferred.
• Claude 3.7’s more detailed explanations might offer more excellent educational value for a deeper understanding of statistical principles.

However, the mathematical precision demonstrated by both models suggests that either would be reliable for calculating vital clinical trial statistics.

Comparing Llama 4 Scout Reasoning vs Claude 3.7 in Clinical Trial Problem Solving

Comparing Llama 4 Scout Reasoning vs Claude 3.5 in Clinical Trial Problem Solving

Conclusion

This limited comparison suggests that Llama 4 Scout Reasoning and Claude 3.7 demonstrate strong capabilities in solving clinical trial statistical problems. However, Llama 4 Scout is open-source, and you can fine-tune it with your data, which will be more powerful.

It’s worth emphasizing that this analysis is based on only three specific problems and should not be extrapolated to represent overall model capabilities across the broad and complex domain of clinical trial statistics. A more comprehensive evaluation would require testing across a broader range of problem types, complexity levels, and specialized statistical methods used in clinical trials.

In today's data-driven world, the ability to quickly extract insights from documents is becoming increasingly valuable. Whether you're a researcher sifting through academic papers, a legal professional analyzing contracts, or a business analyst reviewing reports, the challenge of efficiently navigating through lengthy documents remains universal.

Enter Llama-4-Scout, Meta's latest language model that's showing remarkable capabilities in document question-answering tasks. Released on April 5, 2025, Scout is a groundbreaking addition to the new Llama 4 family, specifically designed to be more reliable, precise, and effective at finding and extracting information from documents.

What Makes Llama-4-Scout Special?

Llama-4-Scout utilizes a Mixture-of-Experts (MoE) architecture with 17 billion active parameters (out of 109 billion total parameters across 16 experts) that strikes an optimal balance between performance and efficiency. What truly sets Scout apart is its unprecedented 10-million token context window, making it best in class for long-context tasks like summarizing huge codebases and analyzing extensive documents.

Scout was pretrained on approximately 40 trillion tokens of multimodal data and excels at:

Document comprehension: Understanding context across extremely long documents

Information retrieval: Precisely locating specific details in complex content

Source attribution: Providing clear references to where information was found

Multimodal reasoning: Visual recognition, image reasoning, captioning, and answering questions about document visuals

This focused design makes Scout particularly well-suited for professional document analysis tasks that require both accuracy and reasonable computational resources. Remarkably, the model fits on a single H100 GPU when quantized to Int4, making it accessible for organizations without massive computing infrastructure.

Real-World Example: Document Q&A on the AGENTS Framework

I recently had the opportunity to test Llama-4-Scout's capabilities by building a simple PDF Q&A application with a research paper on the AGENTS framework (a system for autonomous language agents). The results demonstrated Scout's remarkable ability to extract, understand, and contextualize information from technical documents. Here's what I observed:

Source Paper: https://arxiv.org/pdf/2309.07870

Example 1: Identifying Core Framework Components

When asked about the main features of the framework described in the document, Scout successfully extracted and summarized the key components:

Query: "What are the main features of the AGENTS framework?"

Scout's Response: "The main features of the AGENTS framework include planning, memory (specifically long-short term memory implementation), tool usage capabilities, multi-agent communication protocols, and fine-grained symbolic control through SOPs (Standard Operating Procedures). Source: Page 4, Framework Architecture section"

Example 2: Understanding Technical Implementation Details

Scout excelled at extracting specific technical implementation details related to memory systems:

Query: "How does long-short term memory work in AGENTS?"

Scout's Response: "The AGENTS framework implements a dual-memory system where long-term memories are constructed as action histories embedded by sentence-transformers and stored in VectorDB for semantic search retrieval. In contrast, short-term memories (working memories) are maintained in natural language form and dynamically updated by an LLM through a carefully tuned prompt system. Source: Pages 7-8, Memory Architecture section"

Example 3: Explaining Human-Agent Interaction Mechanisms

The model demonstrated its ability to identify specific configuration details that enable key functionalities:

Query: "How does the AGENTS framework support human-agent interaction?"

Scout's Response: "The AGENTS framework supports human-agent interaction through a simple but effective configuration mechanism. Users can change an agent's 'is_human' field to 'True' in the config file, which enables humans to take the role of an agent and interact with other language agents in both single-agent and multi-agent scenarios. Source: Page 12, Human-Agent Interaction section"

Example 4: Clarifying Domain-Specific Terminology

When asked about specialized terminology in the document, Scout provided clear and accurate explanations:

Query: "What is SOP in the AGENTS framework?"

Scout's Response: "In the AGENTS framework, SOP (Standard Operating Procedures) is a symbolic plan that provides fine-grained control of agents' behaviors. Technically, it's implemented as a graph of multiple states that define different situations an agent may encounter, with explicit transition rules between these states. This architecture makes agents' behavior more stable and predictable across various scenarios. Source: Page 9, Agent Control Mechanisms section"

Example 5: Identifying Ecosystem Components

Scout successfully extracted information about the broader ecosystem supporting the framework:

Query: "What is the Agent Hub in the AGENTS framework?"

Scout's Response: "The Agent Hub is a platform component of the AGENTS framework that enables users to share their fine-tuned language agents and search/download useful language agents created by others. This significantly reduces the effort required for designing, testing, and tuning language agents from scratch, creating a collaborative ecosystem for agent development. Source: Page 15, Ecosystem and Tools section"

Building Your Own Document Intelligence Tool

The ability to build custom applications around Llama-4-Scout is straightforward through providers like Together.ai. I created a simple Streamlit application that allows users to:

• Upload any PDF document
• Process both the text and visual content
• Ask questions in natural language
• Receive answers with source references
• Evaluate answer quality with multiple criteria

This type of application can transform how teams work with documents, significantly reducing the time spent searching for information and improving the accuracy of insights extracted. Scout's ability to process images in documents means it can work with charts, tables, diagrams, and other visual elements that are often critical for full document understanding and is "optimized for visual recognition, image reasoning, captioning, and answering general questions about an image."

Technical Capabilities and Performance

Llama-4-Scout demonstrates impressive performance relative to competing models. In comparative evaluations, Scout has shown "superior performance relative to contemporary models such as Gemma 3, Gemini 2.0 Flash-Lite, and Mistral 3.1 across recognized benchmark datasets."

What makes Scout particularly practical is its efficiency. Scout "fits on a single H100 GPU when quantized to Int4" while still delivering high-quality results. This efficiency means organizations can implement advanced document intelligence without requiring massive computational resources.

Looking Ahead: The Future of Document Intelligence

As models like Llama-4-Scout continue to evolve, we can expect even more sophisticated document intelligence capabilities. Future developments will likely include:

• Deeper reasoning across multiple documents
• More nuanced understanding of domain-specific content
• Better handling of ambiguity and uncertain information
• Enhanced multimodal capabilities for complex visual content

Conclusion

Llama-4-Scout represents a significant step forward in making advanced document intelligence accessible. Its balanced approach to performance and efficiency makes it particularly valuable for professional applications where accuracy and attribution matter.

For organizations dealing with large volumes of documents, investing in tools built around models like Scout could yield substantial returns through improved information accessibility and insight generation. The model's ability to "process and work with extremely lengthy documents" makes it ideal for enterprises with extensive documentation needs.

Have you experimented with Llama-4-Scout or similar models for document analysis? I'd love to hear about your experiences and applications in the comments below.

Note: The examples provided are based on actual testing of Llama-4-Scout through Together.ai's API integration. Results may vary depending on document complexity and specific implementation details.

To be honest, I was shocked when I used Lovable.dev, an AI tool. It made me fearful about job prospects. I’m not an expert, but I have good knowledge of development. However, I haven’t secured a position in a top IT company. For many computer science graduates and those working in startups, it’s a dream to land a job at a major company — it’s a common mindset among middle-class individuals: “How do we secure jobs now?”

After using Lovable.dev and Replit AI, I was stunned. The issue is serious — these AI tools can build entire websites as per specific requirements. Lovable.dev helps with front-end and even generates full-stack boilerplates, while Replit AI goes a step further with integrated front-end, back-end, and database functionalities. Fortunately, Replit AI’s full features are only available with a premium subscription.

The Effect of AI Tools on Jobs for Freshers

AI tools like Lovable.dev raise concerns about job security for freshers in the industry. Because when AI work like this then why company need to hire freshers? This is the focus of today’s blog. Let’s discuss.

After learning about these tools, I connected with professionals working in top IT companies. Initially, they assured me that AI wouldn’t impact job opportunities. But later, I posted about the issue, and one of those same professionals commented, “It is dangerous only.”

The exact words they used in the comment were:
“To be honest, between the time we discussed this and now, a lot has changed, like #vibecoding and stuff. It’s a bit scary.”

This came from my tech mentor and brother, Praveen Kumar Purushothaman, Associate Director of UI Core Architecture at Fitch Group, Inc., London, England, United Kingdom.

Surprisingly, when discussing AI tools within my community, I found that many members, more than just one or two, were completely unaware of them. This led me to write this blog and gather feedback through the following questions:

1. Do you think AI affects job opportunities for freshers?
2. Does it make your work easier?
3. Does your company allow AI-assisted development?
4. If you were a founder, would you encourage or allow your employees to use AI for development?

Community Feedback on AI

Due to busy schedules and a lack of curiosity about these tools, I received only one response — from my brother, Hareesh Rajendran. Here’s his take:

1. Do you think AI affects job opportunities for freshers?
It will have an impact. It won’t eradicate jobs, but it will raise the bar and expectations.

2. Does it make your work easier?
Definitely! I can now write 1,000–10,000 lines of code per day, whereas previously, even 1,000 lines was the max, and that too on a highly productive day.

4. If you were a founder, would you encourage or allow your employees to use AI for development?
100%! I would urge them to adopt AI. If I were a founder, I would even provide them with the best AI subscription.

AI Adoption: A Corporate Decision

In my view, AI tools are shocking and frightening, as I’ve mentioned. But ultimately, major IT companies decide whether AI tools will be used or not. Some top companies already allow developers and interns to utilize AI to enhance efficiency. I know about this from a community friend about 4–6 months ago. However, many companies still prohibit AI-assisted development, making it entirely a company-based decision.

Even though top IT companies embrace AI, they still require developers to have strong knowledge of Data Structures and Algorithms (DSA) for entry-level positions. A few months ago, I read a blog (published by a top press, though I forget the name) that stated:

“IT companies seek developers with knowledge and skills. They allow AI usage but don’t need people who simply copy-paste code generated by AI. When AI-generated code has bugs, developers must have the expertise to fix and explain each line.”

AI’s Impact on Development

At the end of the day, AI adoption depends on company decisions. As a developer, I enjoy using AI — it saves time. I still remember when I first learned web development using HTML, CSS, JavaScript, and Bootstrap. It took me forever to build a single webpage. But now, with AI, we can get a full website front-end for free within one or two hours. With premium access to Replit AI, we can even generate complete websites — including front-end, back-end, and database integration.

Whenever I develop a website, I leverage AI tools like Lovable.dev for front-end development while building the back-end myself. But according to me, we’re in an AI bubble — a phenomenon I frequently discuss with my friends and community. It reminds me of the history an dot-com bubble crash of 2000, when simply having a website for your company could secure funding without needing an actual business model.

Before this AI bubble bursts, we will experience many more shocking advancements, especially for those of us who closely monitor trends and AI releases.

Conclusion

So, is AI a real threat to developers? That remains unclear. AI is certainly dangerous, but it ultimately depends on IT companies’ decisions. However, freshers — especially those working at startups or aiming for positions in major firms — will find it increasingly challenging to secure jobs and retain them.

Freshers who only know HTML, CSS, JavaScript, and Bootstrap might struggle to land positions, even in startups. They must continuously upskill to remain competitive in top IT firms.

Through this blog, I’ve shared my perspective alongside insights from professionals in the IT industry.

When you feel this content is valuable, follow me for more upcoming Blogs.

Connect with Me:

• LinkedIn: Anand Sundaramoorthy
• Instagram: @anandsundaramoorthysa
• Email: sanand03072005@gmail.com

Introduction

Ever wished you could create stunning portraits with just a few clicks? Meet Gibili Portrait Assistance, an AI-powered tool that makes generating high-quality portraits effortless. Whether you’re an artist, designer, or simply someone who loves experimenting with AI, Gibili can help bring your ideas to life.

In this post, we’ll walk you through how to use Gibili Portrait Assistance and explore the OpenAI architecture behind it.

How to Use Gibili Portrait Assistance

Using Gibili is straightforward and requires no prior technical knowledge. Here’s a simple step-by-step guide:

1. Enter Your Description or Upload an Image
You can either type a text description of the portrait you want or upload an existing image to be enhanced or transformed by AI.

Text Prompt Example:

• “A realistic portrait of a woman with curly brown hair, wearing a red scarf, in a cinematic lighting style.”

Image Upload:

• If you have an image you want to modify or enhance, simply upload it, and Gibili will apply AI-powered enhancements or transformations.

2. Customize Your Preferences
You can fine-tune details such as:

• Art Style: Realistic, digital painting, anime, etc.
• Background: Solid color, blurred, natural scenery.
• Facial Expressions: Smiling, neutral, surprised.
• Additional Features: Glasses, hats, jewelry, etc.

3. Generate the Image
Press Enter, and within seconds, Gibili will produce a high-resolution portrait based on your input or uploaded image.

4. Refine and Download
If you want adjustments, you can tweak your input and regenerate until you’re satisfied. Once ready, download your portrait in high-quality format.

The OpenAI Architecture Behind Gibili

Gibili Portrait Assistance is powered by OpenAI’s advanced image generation models, leveraging diffusion models to create highly detailed and realistic portraits. Here’s a simplified breakdown:

1. Text-to-Image & Image-to-Image Generation
When you provide a text prompt, the AI model translates it into a visual representation using deep learning techniques. If you upload an image, the model can enhance, transform, or stylize it while maintaining its core structure.

2. Fine-Tuned on Portrait Data
The model has been trained on a vast dataset of portraits across different styles, ensuring high accuracy and creativity in generated images.

3. Iterative Refinement
Instead of creating the final image instantly, the AI gradually refines it through multiple steps, ensuring greater precision and quality.

4. User-Guided Adjustments
Users can modify parameters like style and background, and the model will intelligently adjust the portrait while maintaining coherence.

Why Use Gibili Portrait Assistance?

✅ Easy to Use

No need for advanced design skills — just describe what you want or upload an image, and AI does the rest.

🎨 Customizable Output

From photorealistic portraits to artistic illustrations, you can tailor the results to your liking.

🚀 Fast & High-Quality

Generate high-resolution images within seconds.

🖌️ Creative Freedom

Perfect for artists, marketers, and content creators looking for unique visuals.

Get Started with Gibili Today!

Ready to create amazing AI-generated portraits? Try Gibili Portrait Assistance now and explore the limitless possibilities of AI-powered creativity!

In the AI Era, we all use AI in our daily lives. Prompting is an efficient way of using AI like ChatGPT, Perplexity, and others. Today, I would like to share the “Power of Prompting” in this blog. But to know the power of prompting, I would like to share my story. How the Prompting should change my life.

As a small introduction, my name is Anand. I am a Front-End Developer, Tech & Finance Enthusiast and have a desire to work as an developer in Top IT company.

Where do I start???

Ok, I am pursuing my Higher Education in Government Aided School. A School filled with the teaching of discipline & education. Due to loosening of strict in school about language. I have no confidence in speaking in English. Even try to speak in English. We all know about the response of friends. How do they tease us?

Fast forward to 2022, I completed my schooling and joined BSc Computer Science. At that time, to be frank, I have no knowledge about tech, coding, hardware, and all. But I have that spark to learn. As we always know, the internet is filled with knowledge. But language is a big barrier to gaining knowledge.

Here is the intro of today’s AI war beginner or the reason for today’s AI war — ChatGPT. In November 2022, the ChatGPT was launched. Due to got an good roommates in my first year. I have know about the power of the internet. So, in that time, I gained the knowledge using only YouTube. Within one week of its release, I started using ChatGPT.

It helps to understand tech, education, and what I want using simple English or English filled with Grammar mistakes. After the lot of prompting I gained more knowledge about tech. Then move on to the courses in various platforms like Coursera, Udemy and other platform. Then move on to Blogs, Research Papers as little bit and more on.

Fast forward today, I have good foundational knowledge in various tech & finance. But the barrier of english and without knowledge of “How search anything in internet deeply?” are broken and the AI acts as good mentor.

Nowadays even though I have gain knowledge through various things from youtube, blogs, AI, research papers, books. This all begin from that. Because without that beginning, now I am nothing.

I think this blog is interesting in the way of denote the “Prompting & my life”. Stay tuned for my tech & finance blogs.

Connect with Me:

• LinkedIn: Anand Sundaramoorthy
• Instagram: @anandsundaramoorthysa
• Email: sanand03072005@gmail.com

ChatGPT made a revolution in human life, it changed many of their lives. Two Months ago I saw a great example of it. Using ChatGPT & LinkedIn, businessman Iwan Richard — Founder & CEO of Reneonix should bring their business to the next level. To know more about their journey check the Being Scenius with Sriram Selvan Podcast the link is below 👇

ChatGPT also plays an important role in my learning journey. So, I like to write a blog about “The Evolution & Backclash of Developers Using ChatGPT”.

Note: Here I write the blog from my perspective, it may be changed for you.

What makes the 100 Million People use the ChatGPT actively in just two months after their launching?

Before the arrival of ChatGPT, the Internet plays a key role in learning anything. The process of visiting many websites and reading many things such as Blogs and articles is good for gaining knowledge. But it consumes more time and makes them tired. ChatGPT changes all things in time of arrival. It gives solutions for most things and explains easily in a way even understand by the children. But at the time of arrival, it does not give solutions for the present-day related questions. But that should be solved and made possible by using various methodologies and advancing the ChatGPT.

But only that reason for using ChatGPT by a million users?

No, ChatGPT has been used by various people for various things. Like learning anything as easily, drafting mail professionally, more and more. Due to the tuning of the AI Model as perfect, they should not answer for bad things. Such a question is related to do crimes. That sounds interesting, right? It has done all things as good with the restrictions of helping bad things. So, it’s good only.

To be frank no. But Why?

Because ChatGPT makes the work easy. For Developers, it gives the basic code and even gives good code then the beginner level developers. However, the developers need sufficient knowledge to explain that code and fix the bug given by ChatGPT. Even Foreign IT Companies are allowed to use ChatGPT and other AI for development. But they expect basic knowledge at the time of their entry into their company. They did not like to hire persons who just copied and pasted the code without the knowledge of how the coding works.

The problem arises for the beginners. One who starts using ChatGPT in their earlier stage is affected in two ways. First, they change them as lazy to code. Due to laziness after some time they struggle to code without ChatGPT. So, they also lose their confidence themself. Like “I Should not code as well or I am not a good developer” and due to laziness, they lose their problem-solving skills. Even the person who has good knowledge in the time of going to the companies for an interview, due to their high dependence on ChatGPT in time of practice, lacks code at the selection round. Second, in time of start learning no one is perfect. No one should develop a website like “Netflix” as straightly. But the ChatGPT had been done that. Here they imagine the AI should replicate the Developer's work as soon. Maybe it is possible but for that also need humans as a main player and just AI as a tool. Because it works by pre-training and scraping data from the web.

What is the Solution?

1. Using AI such as ChatGPT as a tool makes no trouble. However using that as an overload makes the developers lazy, which makes them lose their problem-solving skills.
2. Using ChatGPT at the time of beginning the journey in coding causes more trouble than expected. Why? Because it gives unnecessary thinking, does not help to gain knowledge & more. The Error makes the developer's life as good. So, trying to solve the error yourself in the beginning gives a healthy journey.

In conclusion using AI in development as a tool makes life as more easier, helps debug easily, and is enormously helpful usage. But using it over time gives only trouble.

When feel this content is valuable follow me for more upcoming Blogs.

Connect with Me:

• LinkedIn: Anand Sundaramoorthy
• Instagram: @anandsundaramoorthysa
• Email: sanand03072005@gmail.com

Introduction

Large Language Model (LLM) based AI agents represent a new paradigm in artificial intelligence. Unlike traditional software agents, these systems leverage the powerful capabilities of LLMs to understand, reason, and interact with their environment in more sophisticated ways. This guide will introduce you to the basics of LLM agents and their think-act-observe cycle.

What is an LLM Agent?

An LLM agent is a system that uses a large language model as its core reasoning engine to:

1. Process natural language instructions
2. Make decisions based on context and goals
3. Generate human-like responses and actions
4. Interact with external tools and APIs
5. Learn from interactions and feedback

Think of an LLM agent as an AI assistant who can understand, respond, and take actions in the digital world, like searching the web, writing code, or analyzing data.

The Think-Act-Observe Cycle in LLM Agents

Observe (Input Processing)

LLM agents observe their environment through:

1. Direct user instructions and queries
2. Context from previous conversations
3. Data from connected tools and APIs
4. System prompts and constraints
5. Environmental feedback

Think (LLM Processing)

The thinking phase for LLM agents involves:

1. Parsing and understanding input context
2. Reasoning about the task and requirements
3. Planning necessary steps to achieve goals
4. Selecting appropriate tools or actions
5. Generating natural language responses

The LLM is the "brain," using its trained knowledge to process information and make decisions.

Act (Execution)

LLM agents can take various actions:

1. Generate text responses
2. Call external APIs
3. Execute code
4. Use specialized tools
5. Store and retrieve information
6. Request clarification from users

Key Components of LLM Agents

Core LLM

1. Serves as the primary reasoning engine
2. Processes natural language input
3. Generates responses and decisions
4. Maintains conversation context

Working Memory

1. Stores conversation history
2. Maintains current context
3. Tracks task progress
4. Manages temporary information

Tool Use

1. API integrations
2. Code execution capabilities
3. Data processing tools
4. External knowledge bases
5. File manipulation utilities

Planning System

1. Task decomposition
2. Step-by-step reasoning
3. Goal tracking
4. Error handling and recovery

Types of LLM Agent Architectures

Simple Agents

1. Single LLM with basic tool access
2. Direct input-output processing
3. Limited memory and context
4. Example: Basic chatbots with API access

ReAct Agents

1. Reasoning and Acting framework
2. Step-by-step thought process
3. Explicit action planning
4. Self-reflection capabilities

Chain-of-Thought Agents

1. Detailed reasoning steps
2. Complex problem decomposition
3. Transparent decision-making
4. Better error handling

Multi-Agent Systems

1. Multiple LLM agents working together
2. Specialized roles and capabilities
3. Inter-agent communication
4. Collaborative problem-solving

Common Applications

LLM agents are increasingly used for:

1. Personal assistance and task automation
2. Code generation and debugging
3. Data analysis and research
4. Content creation and editing
5. Customer service and support
6. Process automation and workflow management

Best Practices for LLM Agent Design

Clear Instructions

1. Provide explicit system prompts
2. Define constraints and limitations
3. Specify available tools and capabilities
4. Set clear success criteria

Effective Memory Management

1. Implement efficient context tracking
2. Prioritize relevant information
3. Clean up unnecessary data
4. Maintain conversation coherence

Robust Tool Integration

1. Define clear tool interfaces
2. Handle API errors gracefully
3. Validate tool outputs
4. Monitor resource usage

Safety and Control

1. Implement ethical guidelines
2. Add safety checks and filters
3. Monitor agent behavior
4. Maintain user control

Understanding Attention in Large Language Models: A Beginner's Guide

Have you ever wondered how ChatGPT or other AI models can understand and respond to your messages so well? The secret lies in a mechanism called ATTENTION - a crucial component that helps these models understand relationships between words and generate meaningful responses. Let's break it down in simple terms!

What is Attention?

Imagine you're reading a long sentence: "The cat sat on the mat because it was comfortable." When you read "it," your brain naturally connects back to either "the cat" or "the mat" to understand what "it" refers to. This is exactly what attention does in AI models - it helps the model figure out which words are related to each other.

How Does Attention Work?

The attention mechanism works like a spotlight that can focus on different words when processing each word in a sentence. Here's a simple breakdown:

1. For each word, the model calculates how important every other word is in relation to it.
2. It then uses these importance scores to create a weighted combination of all words.
3. This helps the model understand context and relationships between words.

Let's visualize this with an example:

In this diagram, the word "it" is paying attention to all other words in the sentence. The thickness of the arrows could represent the attention weights. The model would likely assign higher attention weights to "cat" and "mat" to determine which one "it" refers to.

Multi-Head Attention: Looking at Things from Different Angles

In modern language models, we don't just use one attention mechanism - we use several in parallel! This is called Multi-Head Attention. Each "head" can focus on different types of relationships between words.

Let's consider the sentence: The chef who won the competition prepared a delicious meal.

• Head 1 could focus on subject-verb relationships (chef - prepared)
• Head 2 might attend to adjective-noun pairs (delicious - meal)
• Head 3 could look at broader context (competition - meal)

Here's a diagram:

This multi-headed approach helps the model understand text from different perspectives, just like how we humans might read a sentence multiple times to understand different aspects of its meaning.

Why Attention Matters

Attention mechanisms have revolutionized natural language processing because they:

1. Handle long-range dependencies better than previous methods.
2. Can process input sequences in parallel.
3. Create interpretable connections between words.
4. Allow models to focus on relevant information while ignoring irrelevant parts.

Recent Developments and Research

The field of LLMs is rapidly evolving, with new techniques and insights emerging regularly. Here are a few areas of active research:

Contextual Hallucinations

Large language models (LLMs) can sometimes hallucinate details and respond with unsubstantiated answers that are inaccurate with respect to the input context.

The Lookback Lens technique analyzes attention patterns to detect when a model might be generating information not present in the input context.

Extending Context Window

Researchers are working on extending the context window sizes of LLMs, allowing them to process longer text sequences.

Conclusion

While the math behind attention mechanisms can be complex, the core idea is simple: help the model focus on the most relevant parts of the input when processing each word. This allows language models to understand the context and relationships between words better, leading to more accurate and coherent responses.

Remember, this is just a high-level overview - there's much more to learn about attention mechanisms! Hopefully, this will give you a good foundation for understanding how modern AI models process and understand text.

Function calling allows Claude to interact with external functions and tools in a structured way. This guide will walk you through implementing function calling with Claude using Python, complete with examples and best practices.

Prerequisites

To get started, you'll need:

• Python 3.7+
• anthropic Python package
• A valid API key from Anthropic

Basic Setup

from anthropic import Anthropic
import json
# Initialize the client
anthropic = Anthropic(api_key='your-api-key')

Defining Functions

function_schema = {
    "name": "get_weather",
    "description": "Get the current weather for a specific location",
    "parameters": {
        "type": "object",
        "properties": {
            "location": {
                "type": "string",
                "description": "City name or coordinates"
            },
            "unit": {
                "type": "string",
                "enum": ["celsius", "fahrenheit"],
                "description": "Temperature unit"
            }
        },
        "required": ["location"]
    }
}

Making Function Calls

A Step-by-Step Guide to LLM Function Calling in Python
Function calling allows Claude to interact with external functions and tools in a structured way. This guide will walk you through implementing function calling with Claude using Python, complete with examples and best practices.
Prerequisites
To get started, you'll need:
Python 3.7+
anthropic Python package
A valid API key from Anthropic

Basic Setup
from anthropic import Anthropic
import json
# Initialize the client
anthropic = Anthropic(api_key='your-api-key')
Defining Functions
function_schema = {
    "name": "get_weather",
    "description": "Get the current weather for a specific location",
    "parameters": {
        "type": "object",
        "properties": {
            "location": {
                "type": "string",
                "description": "City name or coordinates"
            },
            "unit": {
                "type": "string",
                "enum": ["celsius", "fahrenheit"],
                "description": "Temperature unit"
            }
        },
        "required": ["location"]
    }
}
Making Function Calls
def get_weather(location, unit="celsius"):
    # This is a mock implementation but you can all call your API
    return {
        "location": location,
        "temperature": 22 if unit == "celsius" else 72,
        "conditions": "sunny"
    }
def process_function_call(message):
    try:
        # Parse the function call parameters
        params = json.loads(message.content)
        # Call the appropriate function
        if message.name == "get_weather":
            result = get_weather(**params)
            return json.dumps(result)
        else:
            raise ValueError(f"Unknown function: {message.name}")
    except Exception as e:
        return json.dumps({"error": str(e)})
# Example conversation with function calling
messages = [
    {
        "role": "user",
        "content": "What's the weather like in Paris?"
    }
]
while True:
    response = anthropic.messages.create(
        model="claude-3-5-haiku-latest",
        messages=messages,
        tools=[function_schema]
    )
    # Check if Claude wants to call a function
    if response.tool_calls:
        for tool_call in response.tool_calls:
            # Execute the function
            result = process_function_call(tool_call)
            # Add the function result to the conversation
            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "name": tool_call.name,
                "content": result
            })
    else:
        # Normal response - print and break
        print(response.content)
        break

Best Practices

1. Clear Function Descriptions

• Write detailed descriptions for your functions
• Specify parameter types and constraints clearly
• Include examples in the descriptions when helpful

1. Input Validation

• Validate all function inputs before processing
• Return meaningful error messages
• Handle edge cases gracefully

1. Response Formatting

• Return consistent JSON structures
• Include status indicators in responses
• Format error messages uniformly

4 . Security Considerations

• Validate and sanitize all inputs
• Implement rate limiting if needed
• Use appropriate authentication
• Don't expose sensitive information in function descriptions

Conclusion

Function calling with Claude enables powerful integrations between the language model and external tools. By following these best practices and implementing proper error handling, you can create robust and reliable function-calling implementations.

In the rapidly evolving landscape of artificial intelligence, Retrieval Augmented Generation (RAG) systems have emerged as a crucial technology for enhancing Large Language Models with external knowledge. However, ensuring the quality and reliability of these systems requires robust evaluation methods. Enter RAGAS (Retrieval Augmented Generation Assessment System), a groundbreaking framework that provides comprehensive metrics for evaluating RAG systems.

The Importance of RAG Evaluation

RAG systems combine the power of retrieval mechanisms with generative AI to produce more accurate and contextually relevant responses. However, their complexity introduces multiple potential points of failure, from retrieval accuracy to answer generation quality. This is where RAGAS steps in, offering a structured approach to assessment that helps developers and organizations maintain high standards in their RAG implementations.

Core RAGAS Metrics

Context Precision

Context precision measures how relevant the retrieved information is to the given query. This metric evaluates whether the system is pulling in the right pieces of information from its knowledge base. A high context precision score indicates that the retrieval component is effectively identifying and selecting relevant content, while a low score might suggest that the system is retrieving tangentially related or irrelevant information.

Faithfulness

Faithfulness assesses the alignment between the generated answer and the provided context. This crucial metric ensures that the system's responses are grounded in the retrieved information rather than hallucinated or drawn from the model's pre-trained knowledge. A faithful response should be directly supported by the context, without introducing external or contradictory information.

Answer Relevancy

The answer relevancy metric evaluates how well the generated response addresses the original question. This goes beyond mere factual accuracy to assess whether the answer provides the information the user was seeking. A highly relevant answer should directly address the query's intent and provide appropriate detail level.

Context Recall

Context recall compares the retrieved contexts against ground truth information, measuring how much of the necessary information was successfully retrieved. This metric helps identify cases where critical information might be missing from the system's responses, even if what was retrieved was accurate.

Practical Implementation

RAGAS's implementation is designed to be straightforward while providing deep insights. The framework accepts evaluation datasets containing:

Questions posed to the system
Retrieved contexts for each question
Generated answers
Ground truth answers for comparison

This structured approach allows for automated evaluation across multiple dimensions of RAG system performance, providing a comprehensive view of system quality.

Benefits and Applications

Quality Assurance

RAGAS enables continuous monitoring of RAG system performance, helping teams identify degradation or improvements over time. This is particularly valuable when making changes to the retrieval mechanism or underlying models.

Development Guidance

The granular metrics provided by RAGAS help developers pinpoint specific areas needing improvement. For instance, low context precision scores might indicate the need to refine the retrieval strategy, while poor faithfulness scores might suggest issues with the generation parameters.

Comparative Analysis

Organizations can use RAGAS to compare different RAG implementations or configurations, making it easier to make data-driven decisions about system architecture and deployment.

Best Practices for RAGAS Implementation

1. Regular Evaluation Implement RAGAS as part of your regular testing pipeline to catch potential issues early and maintain consistent quality.
2. Diverse Test Sets Create evaluation datasets that cover various query types, complexities, and subject matters to ensure robust assessment.
3. Metric Thresholds Establish minimum acceptable scores for each metric based on your application's requirements and use these as quality gates in your deployment process.
4. Iterative Refinement Use RAGAS metrics to guide iterative improvements to your RAG system, focusing on the areas showing the lowest performance scores.

Practical Code Examples

Basic RAGAS Evaluation

Here's a simple example of how to implement RAGAS evaluation in your Python code:

from ragas import evaluate
from datasets import Dataset
from ragas.metrics import (
    faithfulness,
    answer_relevancy,
    context_precision
)

def evaluate_rag_system(questions, contexts, answers, references):
    """
    Simple function to evaluate a RAG system using RAGAS

    Args:
        questions (list): List of questions
        contexts (list): List of contexts for each question
        answers (list): List of generated answers
        references (list): List of reference answers (ground truth)

    Returns:
        EvaluationResult: RAGAS evaluation results
    """
    # First, let's make sure you have the required packages
    try:
        import ragas
        import datasets
    except ImportError:
        print("Please install required packages:")
        print("pip install ragas datasets")
        return None

    # Prepare evaluation dataset
    eval_data = {
        "question": questions,
        "contexts": [[ctx] for ctx in contexts],  # RAGAS expects list of lists
        "answer": answers,
        "reference": references
    }

    # Convert to Dataset format
    eval_dataset = Dataset.from_dict(eval_data)

    # Run evaluation with key metrics
    results = evaluate(
        eval_dataset,
        metrics=[
            faithfulness,      # Measures if answer is supported by context
            answer_relevancy,  # Measures if answer is relevant to question
            context_precision  # Measures if retrieved context is relevant
        ]
    )

    return results

# Example usage
if __name__ == "__main__":
    # Sample data
    questions = [
        "What are the key features of Python?",
        "How does Python handle memory management?"
    ]

    contexts = [
        "Python is a high-level programming language known for its simple syntax and readability. It supports multiple programming paradigms including object-oriented, imperative, and functional programming.",
        "Python uses automatic memory management through garbage collection. It employs reference counting as the primary mechanism and has a cycle-detecting garbage collector for handling circular references."
    ]

    answers = [
        "Python is known for its simple syntax and readability, and it supports multiple programming paradigms including OOP.",
        "Python handles memory management automatically through garbage collection, using reference counting and cycle detection."
    ]

    references = [
        "Python's key features include readable syntax and support for multiple programming paradigms like OOP, imperative, and functional programming.",
        "Python uses automatic garbage collection with reference counting and cycle detection for memory management."
    ]

    # Run evaluation
    results = evaluate_rag_system(
        questions=questions,
        contexts=contexts,
        answers=answers,
        references=references
    )

    if results:
        # Print results
        print("\nRAG System Evaluation Results:")
        print(results)  

Attended the FOSS United Chennai Meetup Yesterday!

After, attending Grafana & Friends Meetup, straightly went to FOSS United Chennai Meetup at YuniQ in Taramani.

Had a chance to meet my Friends face to face after a long time. Sakhil Ahamed E. , Dhanasekar T, Dhanasekar Chellamuthu, Thanga Ayyanar, Parameshwar Arunachalam, Guru Prasath S, Krisha, Gopinathan Asokan

Talks Summary,

1. Ansh Arora, Gave a tour on FOSS United, How its formed, Motto, FOSS Hack, FOSS Clubs.

2. Karthikeyan A K, Gave a talk on his open source product injee (The no configuration instant database for frontend developers.). It’s a great tool. He gave a personal demo for me. It’s a great tool with lot of potentials. Would like to contribute !.

3. Justin Benito, How they celebrated New Year with https://tamilnadu.tech
It’s single go to page for events in Tamil Nadu. If you are interested ,go to the repo https://lnkd.in/geKFqnFz and contribute.

From Kaniyam Foundation we are maintaining a Google Calendar for a long time on Tech Events happening in Tamil Nadu https://lnkd.in/gbmGMuaa.

4. Prasanth Baskar, gave a talk on Harbor, OSS Container Registry with SBOM and more functionalities. SBOM was new to me.

5. Thanga Ayyanar, gave a talk on Static Site Generation with Emacs.

At the end, we had a group photo and went for tea. Got to meet my Juniors from St. Joseph’s Institute of Technology in this meet. Had a discussion with Parameshwar Arunachalam on his BuildToLearn Experience. They started prototyping an Tinder app for Tamil Words. After that had a small discussion on our Feb 8th Glug Inauguration at St. Joseph’s Institute of Technology Dr. KARTHI M .

Happy to see, lot of minds travelling from different districts to attend this meet.

Introduction to RAG and GraphRAG

What is RAG?

RAG, or Retrieval-Augmented Generation, is a technique that combines information retrieval with text generation to produce more accurate and contextually relevant responses. It works by retrieving relevant information from a knowledge base and then using that information to augment the input to a large language model (LLM).

What is GraphRAG?

GraphRAG is an extension of the RAG framework that incorporates graph-structured knowledge. Instead of using a flat document-based retrieval system, GraphRAG utilizes graph databases to represent and query complex relationships between entities and concepts.

Applications of RAG and GraphRAG

RAG Applications

1. Question-answering systems
2. Chatbots and virtual assistants
3. Content summarization
4. Fact-checking and information verification
5. Personalized content generation

GraphRAG Applications

1. Knowledge graph-based question answering
2. Complex reasoning tasks
3. Recommendation systems
4. Fraud detection and financial analysis
5. Scientific research and literature review

Pros and Cons of RAG

Pros of RAG

1. Improved accuracy: By retrieving relevant information, RAG can provide more accurate and up-to-date responses.
2. Reduced hallucinations: The retrieval step helps ground the model's responses in factual information.
3. Scalability: Easy to update the knowledge base without retraining the entire model.
4. Transparency: The retrieved documents can be used to explain the model's reasoning.
5. Customizability: Can be tailored to specific domains or use cases.

Cons of RAG

1. Latency: The retrieval step can introduce additional latency compared to pure generation models.
2. Complexity: Implementing and maintaining a RAG system can be more complex than using a standalone LLM.
3. Quality-dependent: The system's performance heavily relies on the quality and coverage of the knowledge base.
4. Potential for irrelevant retrievals: If the retrieval system is not well-tuned, it may fetch irrelevant information.
5. Storage requirements: Maintaining a large knowledge base can be resource-intensive.

Pros and Cons of GraphRAG

Pros of GraphRAG

1. Complex relationship modeling: Can represent and query intricate relationships between entities.
2. Improved context understanding: Graph structure allows for better capturing of contextual information.
3. Multi-hop reasoning: Enables answering questions that require following multiple steps or connections.
4. Flexibility: Can incorporate various types of information and relationships in a unified framework.
5. Efficient querying: Graph databases can be more efficient for certain types of queries compared to traditional databases.

Cons of GraphRAG

1. Increased complexity: Building and maintaining a knowledge graph is more complex than a document-based system.
2. Higher computational requirements: Graph operations can be more computationally intensive.
3. Data preparation challenges: Converting unstructured data into a graph format can be time-consuming and error-prone.
4. Potential for overfitting: If the graph structure is too specific, it may not generalize well to new queries.
5. Scalability concerns: As the graph grows, managing and querying it efficiently can become challenging.

Comparing RAG and GraphRAG

When to Use RAG

• For general-purpose question-answering systems
• When dealing with primarily textual information
• In scenarios where quick implementation and simplicity are priorities
• For applications that don't require complex relationship modeling

When to Use GraphRAG

• For domain-specific applications with complex relationships (e.g., scientific research, financial analysis)
• When multi-hop reasoning is crucial
• In scenarios where understanding context and relationships is more important than raw text retrieval
• For applications that can benefit from a structured knowledge representation

Future Directions and Challenges

Advancements in RAG

1. Improved retrieval algorithms
2. Better integration with LLMs
3. Real-time knowledge base updates
4. Multi-modal RAG (incorporating images, audio, etc.)

Advancements in GraphRAG

1. More efficient graph embedding techniques
2. Integration with other AI techniques (e.g., reinforcement learning)
3. Automated graph construction and maintenance
4. Explainable AI through graph structures

Common Challenges

1. Ensuring data privacy and security
2. Handling biases in knowledge bases
3. Improving computational efficiency
4. Enhancing the interpretability of results

Conclusion

Both RAG and GraphRAG represent significant advancements in augmenting language models with external knowledge. While RAG offers a more straightforward approach suitable for many general applications, GraphRAG provides a powerful framework for handling complex, relationship-rich domains. The choice between the two depends on the specific requirements of the application, the nature of the data, and the complexity of the reasoning tasks involved. As these technologies continue to evolve, we can expect to see even more sophisticated and efficient ways of combining retrieval, reasoning, and generation in AI systems.

Today, I want to capture notes that I learnt from trailhead academy on connecting postman to a salesforce org.

To make postman allow changes at Salesforce org, we have to enable CORS policy in Salesforce. See below what does CORS mean.

CORS- Cross Origin Resource Sharing

It is a browser feature that controls how resources are requested from one site to another site. By configuring CORS, it enables special permissions for other external websites to access our salesforce data. In this case, we are enabling CORS for postman to access salesforce.

• From setup ==> search for CORS ==> Add https://*.postman.co and https://*.postman.com URL
• After that, in postman desktop -Do below steps one by one.
• Create a separate workspace for Salesforce APIs to play around.
• Search for Salesforce APIs. It does list out all the available collections.
• Fork “Salesforce Platform API” and it will available to your local postman workspace.
• After that, go to “Authorization” click on “Generate token” and copy “instance” URL.
• Configure “_endpoint” value from variable tab as “instance” URL
• All set and that’s it. You can play around whatever requests that are available.

Today, I want to capture notes that I learnt from trailhead academy on connecting postman to a salesforce org.

To make postman allow changes at Salesforce org, we have to enable CORS policy in Salesforce. See below what does CORS mean.

CORS- Cross Origin Resource Sharing

It is a browser feature that controls how resources are requested from one site to another site. By configuring CORS, it enables special permissions for other external websites to access our salesforce data. In this case, we are enabling CORS for postman to access salesforce.

• From setup ==> search for CORS ==> Add https://*.postman.co and https://*.postman.com URL
• After that, in postman desktop -Do below steps one by one.
• Create a separate workspace for Salesforce APIs to play around.
• Search for Salesforce APIs. It does list out all the available collections.
• Fork “Salesforce Platform API” and it will available to your local postman workspace.
• After that, go to “Authorization” click on “Generate token” and copy “instance” URL.
• Configure “_endpoint” value from variable tab as “instance” URL
• All set and that’s it. You can play around whatever requests that are available.

In this blog, i write about SLI, SLA, SLO . I got a refreshing session from a podcast https://open.spotify.com/episode/2Ags7x1WrxaFLRd3KBU50K?si=vbYtW_YVQpOi8HwT9AOM1g. This blog is about that.

In the world of service reliability and performance, the terms SLO, SLA, and SLI are often used interchangeably but have distinct meanings. This blog explains these terms in detail, their importance, and how they relate to each other with practical examples.

1. What are SLIs, SLOs, and SLAs?

Service Level Indicators (SLIs)

An SLI is a metric that quantifies the level of service provided by a system. It measures specific aspects of performance or reliability, such as response time, uptime, or error rate.

Example:

• Percentage of successful HTTP requests over a time window.
• Average latency of API responses.

Service Level Objectives (SLOs)

An SLO is a target value or range for an SLI. It defines what “acceptable” performance or reliability looks like from the perspective of the service provider or user.

Example:

• “99.9% of HTTP requests must succeed within 500ms.”
• “The application should have 99.95% uptime per quarter.”

Service Level Agreements (SLAs)

An SLA is a formal contract between a service provider and a customer that specifies the agreed-upon SLOs and the consequences of failing to meet them, such as penalties or compensations.

Example:

• “If the uptime drops below 99.5% in a calendar month, the customer will receive a 10% credit on their monthly bill.”

2. Relationship Between SLIs, SLOs, and SLAs

• SLIs are the metrics measured.
• SLOs are the goals or benchmarks derived from SLIs.
• SLAs are agreements that formalize SLOs and include penalties or incentives.

SLI: Average latency of API requests.
SLO: 95% of API requests should have latency under 200ms.
SLA: If latency exceeds the SLO for two consecutive weeks, the provider will issue service credits.

3. Practical Examples

Example 1: Web Hosting Service

• SLI: Percentage of time the website is available.
• SLO: The website must be available 99.9% of the time per month.
• SLA: If uptime falls below 99.9%, the customer will receive a refund of 20% of their monthly fee.

Example 2: Cloud Storage Service

• SLI: Time taken to retrieve a file from storage.
• SLO: 95% of retrieval requests must complete within 300ms.
• SLA: If retrieval times exceed 300ms for more than 5% of requests in a billing cycle, customers will get free additional storage for the next month.

Example 3: API Service

• SLI: Error rate of API responses.
• SLO: Error rate must be below 0.1% for all requests in a day.
• SLA: If the error rate exceeds 0.1% for more than three days in a row, the customer is entitled to a credit worth 5% of their monthly subscription fee.

Below listed are the high level steps involved to create a basic Django application.

1. install python
2. use venv before installing django =>python -m venv tutorial-env
3. activate the venv: tutorial-env\Scripts\activate
4. install django in the venv=> python -m pip install django
5. check version =>django-admin –version
6. Create a django project => django-admin startproject myApp
7. To start the webserver =>python manage.py runserver
8. From the myApp location, open cmd and type code .=> which will open vs code for this project from VSCode 1. init.py => when the proj receives a request it will understand that this is a package with the help of this init file 2.asgi & wsgi =>Both required during deployment 3.settings.py =>DB, Language, Timezone, Static, URL etc.,
9. URLs.py => will contain the list of urls used for the project
10. outside of myApp, db.sqlite3 will be used by default as a lite weight DB
11. Manage.py =>Very important file
12. Within the project myAPP, we can create multiple application. to create a new app => python manage.py startapp blog 1.migrations => DB related
    1. init => represent that it is a pkg
    2. admin => for admin purposes
    3. apps => app related config eg: name of the app etc.,
    4. models => contents 6.tests => used for testing the app 7.views 10.Register the app: from myApp->setting.py under Installed_Apps ->add the recently created app ‘blog’ 11.Create the first View:(in general we will receive the request and send back the response) from blog->views.py 1.import HTTPResponse => from django.http import HttpRespose a. Create a python function which take request as a parameter and return the HttpResponse=>A static string output 2.under blog, create a python file by name “urls.py” a.within that file add the urlpatterns list similar to myApp->urls.pyb.in this file, import path, and view from the project->from . import views c.to the urlpatterns list add and entry to the python function created under views.py path(“”<“” represents home directory>,views.index,name=”index”) 3.In myApp-> urls.py a. import path,include from django.urls b. under urlpatterns, add path(“”,include(“blog.urls”)) –> including the url from the blog->urls.py
       1. Time to test the changes. Go to the application url. it should show the content from views.py->index function
       2. Alternatively if we want to call the index with a seperate url a. from the myApp->urls.py-> in the urlpatterns.path -> instead of “”, provide “blogs/” b. Test the same with both default application url and url/blogs