Super charge your Ghala shop by getting latest updates on certain events as they occur on the system. Its simple to listen for specific event and make updates accordingly. This enables shop owners to tap into the power of Ghala webhook to connect with any external service.

Ghala, now lets you listen to some event happens on your  shop. Do you have a system that you like to receive event. This feature comes in handy with some security measures to ensure events are easily verified on the receiving end.

You might ask why have this while i can all do it on the platform, i just need to navigate to the dashboard and get all latest details? Its correct, the platform is already packed with all you need. Ghala already hands you with notifications via either email or SMS only on successful payment but notifications do not provide a way for you/your dev team to automate other tasks such connecting with Logistics handler,

Ohh, this is the developer looking like feature right? I guess so but whoever has the ability to connect and listen to events from Ghala should benefit  from the feature.

Much of the talk lets get a bit a gist of what it means to have and connect to the webhook service. Lets get into developer mode...

About Webhook

I'm not good at story telling but will try to get the about of webhook in a story fashion, just a short one.

Ghala Wehbook, works like an alarm. You would set to ring at 0500 to wake you up. When alarm goes off at 0500, you can either snooze or dismiss it [options in my Alarm]. With snoozed alarm, you will keep getting alarms after a particular interval. In case you dismiss it, the alarm never goes off again..

The same way Ghala webhook works, when. you decide to listen for a particular event, you will get notified almost immediately then you will have to acknowledge(dismiss). In case you do not acknowledge,(snooze), you will get a request after a defined intervals.

Webhook Events

Currently, we support only 4 kind of events namely order creation, order cancelled, order updated and successful payment.

Lets explore sample request that will be sent to the configured URL.

• Order Created

Enum:  order.created

Sample Request:

{
  "event": "order.created",
  "data": {
    "customer": {
      "name": "Sarufi Ghala",
      "phone": "255757294146",
      "email": "info@ghala.io"
    },
    "order": {
      "id": 1,
      "total": 1000,
      "currency": "TZS",
      "products": [{ "name": "Product 1", "price": 500, "quantity": 2 }]
    }
  }
}

• Order Cancelled

Enum: order.cancelled

Sample Data

{
  "event": "order.cancelled",
  "data": {
    "customer": {
      "name": "Sarufi Ghala",
      "phone": "255757294146",
      "email": "info@ghala.io"
    },
    "order": {
      "id": 1,
      "total": 1000,
      "currency": "TZS",
      "products": [{ "name": "Product 1", "price": 500, "quantity": 2 }]
    }
  }
}

• Order Updated

Enum: order.updated

Sample Data:

{
  "event": "order.updated",
  "data": { "order_id": 1, "old_status": "paid", "new_status": "picked up" }
}

• Sucessful payment

Enum:

Sample Data:

{
  "event": "payment.success",
  "daata": {
    "customer": {
      "name": "Sarufi Ghala",
      "email": "info@ghala.io",
      "phone_number": "255757294146"
    },
    "amount": 1000,
    "payment_number": "255757294146",
    "transaction_id": 1,
    "order_id": 1
  }
}

With Ghala, the events are gracefully retried after the following intervals 2 minutes, 5 minutes, 30 minutes,  2 hours, 5 hours and 12 hours. This is when the receiving system snoozes the request from Ghala.

Setting Webhook

The first thing required is to have a live API that will receive events. Login into your Ghala shop, then navigate to setting then on integration tab. Then fill in all required fields > Save or Test the event

Keep in mind that only active webhooks will be triggered. After saving you will have a secret key, keep it as it will be used to create signature that will be part of request headers.

Webhook Security

With webhook set,  webhook secret key provided. Lets take a look on how to verify webhook events from Ghala. Taking into consideration of concerning nature of events and possible consequences that may occur, Ghala has provided a way to verify events against common attacks.

To ensure the authenticity of received events from Ghala, the following verification have been put in place:

• Avoiding replay attacks
• Signature validation

Avoid Replay Attacks

Inside the webhook header there is an additional field X-Ghala-timestamp to indicate the Unix timestamp  when the webhook was signed.  This can be used to  timestamp to reduce the chance of a replay attack.

Signature Validation

Events sent from our Ghala contain the X-Ghala-Signature header. To ensure the webhook's authenticity and confirm its origin from our service,  we recommend following the following steps to compare a generated signature with the signature from the header.

• Construct the signed content

To generate the signed content, concatenate the X-Ghala-timestamp and the raw request body. The raw request body is the JSON payload sent in the request.   Use `.` as the separator between the timestamp and the raw request body as string.

headers = request.headers
# 1. Get headers [signature and timestamp]
signature = headers.get("X-Ghala-Signature")
timestamp = headers.get("X-Ghala-timestamp")

# 2. Get the body
body = await request.body()

# 3. Decode the body
decoded_body = body.decode()

# 4. create a signed payload [do not alter the order]
content = f"{timestamp}.{decoded_body}"

# 5. Encode the payload
 content = content.encode("utf-8")

Make sure to use a raw body as any modification to the body will result in a different signature

• Generate the expected signature

Lets calculate, expected signature  you will need use secret key obtained during registration of webhook.  You will need to use the secret key and signed content, to generate a HMAC SHA256 signature as bytes.

import hmac
import hashlib
import base64

secret_key="your_secret_key" # Obtained when registering the webhook
secret_key = secret_key.encode('utf-8')

 # Create a new signature from content
 new_signature = hmac.new(secret, content, hashlib.sha256).digest()
 
 # Create a base64 encoded signature
 expected = base64.b64encode(new_signature).decode("utf-8").strip()

• Compare the generated signature with the signature from the header

As highlighted above the header will have the signature that was used to sign the request. Compare the generated signature with the signature from the header.

If the two signatures match, the request is valid then you can proceed with processing the event.

Any response status code other than 200, 201 or 202 will be considered as a snoozed alarm so there will be a retry.

It is recommended to use a constant-time string comparison to prevent any possibility of timing attack.

Sample Code

Starter code to get you started with webhook data verification. More eamples will be updated on official ghala docs. Other sample codes will be update as fast as possible to fuel the integration with other systems.

import base64
import hashlib
import hmac

from flask import Flask, request

app = Flask(__name__)

@app.route('/webhook', methods=['POST'])
def webhook(request: Request):
	
    # 1. Construct the signed content
	headers = request.headers
	request_body = request.get_data(as_text=True)
	
    webhook_timestamp = headers.get('X-Ghala-timestamp')

    signed_content = f"{str(webhook_timestamp)}.{str(request_body)}".encode()
    
    # 2. Generate the expected signature
    secret_key="your_secret_key" # Obtained when registering the webhook
    secret_key = secret_key.encode('utf-8')
    
    # New hmac signature
    signature = hmac.new(secret_key, signed_content, hashlib.sha256).digest()
    # Encode the signature to base64
    signature = base64.b64encode(signature).decode()
    
    # 3. Compare the generated signature with the signature from the header
    gahala_signature = headers.get("X-Ghala-Signature")
    if not hmac.compare_digest(gahala_signature, signature):
    
    	# Return any   status code that is not among [200,201,202]
        return "Invalid request", 400
	# Perform your actions with data provided then return status code among [200,201,202]
    # It can be a background task as the request timeout is about 10s
    
    return "Processed",200

Its getting that developer vibe , so get ready for a lot of integration support that are currently on the way. We start by the beta realise of Webhook support..

Wrap up

With Webhook, Ghala intends to bring developer close to integration with existing systems. More features to come stay alert.

With social platforms being the major Go-To sales platforms for many businesses around Tanzania and other areas around the globe, business owners sometimes find it difficult to manage some of customer interactions leading to loss of potential sales. Why not adapt the automation on same platforms that sellers are already comfortable with, mostly WhatsApp.

That lead to development of Sarufi to automate customer interaction chatbots.  As the famous quote goesIf you can’t beat them, join them, Sarufi made possible to join the platforms[social platforms]  in enhancing customer engagement via chatbot.

Sarufi being developer centric, most business people found it a bit of heavy lifting task to get something scratched super quickly and integrated. With the increase of users building commerce experience via Sarufi Chatbots, the Sarufi-like commerce focused solution had be to thought of and sketched.  Then, here we are with the introduction of  a Beta twin platform focusing on commerce experience, 🛒🛍️ Ghala (simplify translates to Store/WareHouse).

Here is a bit of what you would need to do if you had to use sarufi to build a commerce experience for your shop thing.  Its just a very high overview of the tasks that you would have to do manually to get this at least to place order.  With Sarufi you will have to create a chatbot, handle some external site integrations and managing user navigation on viewing products from your API and rendering to the chatbot.

Lets make it easy for business owners to have easiest way of handling their sales as what they care most is how you get them increase their sale on the same platform they are used to. Ghala comes to rescue...

Ghala Brief

Ghala is sarufi twin focusing on commerce to streamline the commerce experience that takes place on social platforms.  It is made to be commerce friendly to seller and customers, provide customers with best experience. Currently supporting WhatsApp integration.

What does the business care about?

• Customer experience
• Sales
• Management

Ghala brings the solution by focusing on what business would be caring about, automating most of the parts involved in business-Customer interaction.  Helping business owners manage customer interaction and order processing is the key focus of Ghala.

The Seller just sets up the shop, then would be notified of new order, with order details. The chatbot underneath is able of responding to most FAQs as provided by the business.

Ohh wait, isn't that whatsApp business you might ask 🤔? Oukay, clarification below.

Ghala utilizes WhatsApp business features, but providing more automation such as payment collection, order management. Currently, using WhatsApp business App you can not automatically collect payment with exception of few countries. Ghala focuses on making the progress on automation via socials faster especially around Africa. You can read a bit on the difference between WhatsApp App vs Cloud API.

Dashboard.

As highlighted on the above image, you would expect the dashboard to allow easy management. The dashboard is intended to be as simple as possible to use.

I know the question in mind is like, ohh wait i want to see a bit of customer interaction kiddooo... 🤔 , Got a video for you here.

Coming Up

With beta version of Ghala to be out, the building iteration continues

• External PSP (Payment Service Provider) integration
• Delivery Services Integration
• Many more for business experience features

Let catch up

Let connect in case you have question  twitter

What is this about 💡

This is a short guide on building a product recommendation system using association rules. For simple next item suggestion from list of previous items. Also good for tasks that just need a quick recommender

Purpose of the Recommendation System

The main goal of this recommendation system is to enhance the shopping experience by providing personalized suggestions to customers. By analyzing past transaction data, we can identify patterns and relationships between different products. These insights allow us to recommend complementary ingredients that customers might be interested in, helping them discover new products and make more informed purchasing decisions.

But we won't do that

This tutorial is designed for data enthusiasts, developers, and anyone interested in doing what was described i last section. And since i have you here, we all are going to suggest food ingredients 😋

2. Prerequisites

Basic Knowledge of Python

Before diving into this tutorial, it is essential to have a basic understanding of Python programming. Familiarity with Python's syntax and basic data structures will help you follow along with the code examples and understand the logic behind the implementation.

• A little bit of pandas then yours good skills in copy pasting if you won't mind

Introduction to Association Rule Mining and Its Importance

Association rule mining is a data mining technique used to identify interesting relationships or patterns between different items in large datasets. It is particularly useful in market basket analysis, where the goal is to discover associations between products purchased together.
in this case ingredients that occur together.

3. Setting Up the Environment

Tools and Libraries

We'll be using Python, along with the pandas and mlxtend libraries for data manipulation and association rule mining.

Installation Instructions

First, make sure you have Python installed on your system. You can download and install Python from the official website. Once Python is installed, you'll need to install the necessary libraries. You can do this using pip, the Python package installer.

Open your terminal or command prompt and run the following commands:

pip install pandas mlxtend

4. Preparing the Dataset

Dataset to Use

I had a quick chat with chatGPT and i aked for can you mention 50 traditional Tanzanian foods then now for each traditional Tanzanian food you mentioned, mention its ingredients in a python list. create ingredients = [ [food 1], [food 2] ... ]. and this was the return

ingredients = [
    ["maize flour", "water", "salt"],  # Ugali
    ["beef", "goat meat", "salt", "spices"],  # Nyama Choma
    ["flour", "meat", "vegetables", "spices", "oil"],  # Samosa
    ["flour", "water", "salt", "oil"],  # Chapati 
    # ... more  ...
]

😂 who uses salt in ugali ?, if you do you are weird ...

Creating the Data

We'll use the TransactionEncoder from the mlxtend library to convert the list of transactions into a format suitable for analysis.

import pandas as pd
from mlxtend.preprocessing import TransactionEncoder

# Initialize the TransactionEncoder
te = TransactionEncoder()
te_ary = te.fit_transform(ingredients)

# Convert to DataFrame
df = pd.DataFrame(te_ary, columns=te.columns_)

5. Generating Association Rules

Frequent Itemsets

Use the Apriori algorithm to generate frequent itemsets from the transaction data. These itemsets represent combinations of ingredients that appear together frequently.

from mlxtend.frequent_patterns import apriori

# Generate frequent itemsets with a minimum support of 0.2
frequent_itemsets = apriori(df, min_support=0.2, use_colnames=True)

Association Rules

Next, we will derive association rules from the frequent itemsets. These rules will help us understand the relationships between different products.

from mlxtend.frequent_patterns import association_rules

# Generate association rules with a minimum confidence of 0.6
rules = association_rules(frequent_itemsets, metric="support", min_threshold=0.2)

6. Creating the Recommendation Function

We will define a function to recommend products based on the association rules. This function will take a list of products and return a dictionary of recommended products with their support percentages.

# here ingredients -> products

def recommend_ingredients(products, rules=rules, top_n=10):
    rules['antecedents'] = rules['antecedents'].apply(lambda x: tuple(x))
    rules['consequents'] = rules['consequents'].apply(lambda x: tuple(x))
    recommendations = rules[rules['antecedents'].apply(lambda x: any(product in x for product in products))]
    recommendations = recommendations.sort_values(by=['confidence', 'lift'], ascending=False)
    top_recommendations = recommendations.head(top_n)

    result = []
    for _, row in top_recommendations.iterrows():
        for item in row['consequents']:
            if item not in result:
                result.append(item.lower())
    return result

7. Testing the Recommendation System

Example Usage

Let's test the recommendation system with an example list of ingredients.

product_list = ['oil', 'salt']
prods = recommend_ingredients(product_list)

print(prods)

Expected Output

The output will be a dictionary of recommended products along with their support percentages, showing which ingredients are most frequently associated with the input.

8. Conclusion

Recap

In this tutorial, we have walked through the process of building a recommendation system using association rules. We covered data preparation, frequent itemset generation, rule mining, and how to create a recommendation function based on these rules.

Further Exploration

You can further explore by experimenting with different datasets, adjusting the parameters for the Apriori algorithm, and fine-tuning the recommendation function. This will help you understand the nuances of association rule mining and its application in various domains.

⚠️ Also go read about the terms in used like support, confidence and lift.

Additional Resources

• Source Codes for all this stuff at github.com/eddiegulay
• Association Rule Mining in Python with mlxtend
• Pandas Documentation

9. Q&A Section

Common Questions

What if my dataset is large?

• For large datasets, consider using more efficient algorithms or sampling methods to handle the data efficiently.

How do I choose the right support and confidence thresholds?

• Experiment with different thresholds to find a balance between generating useful rules and avoiding too many irrelevant ones.

Can I use this method for other types of data?

• Yes, association rule mining can be applied to various types of transactional data, not just kitchen ingredients.

10. Finally

If you are a programmer go finish that project, stop procrastinating. for others it's been nice to have you here 🙂

Sarufi has evolved from CLI tool to Web Dashboard now to a bit collaborative workspace way, V0.2. The new dashboard comes with a lot of improvement starting with workflow.

This is a detailed guide on the new dashboard, to get you familiar walking around your Sarufi garden of chatbots and users. The platform keeps evolving from time to time. This sometimes makes it hard for legacy and new users to navigate around properly.

As always taking a walk around your garden makes proper maintenance  easy. After some time in design and Development we have Sarufi V0.2 out on the main site.

Overall overview

Using sketches makes stuffs easy to grasp, I will be using a lot of them in this walk. Starting with Dashboard as whole seen below.

The diagram show the overview of the dashboard. Lets take a look into these major changes available. The major change is introduction of Workspace as workbench for collaboration among team members.

A user owns a workspace that holds all resources as simple as that, meaning the change is ownership order. Each workspace is an independent entity that houses its own resources.

Lets start our quick navigation around our sarufi garden.

Workspace

The workspace as said above is the major part of the system, lets explore what it contains. On sign up, you will be required to create your profile and create a workspace as its your workbench.

In workspace, you will find a lot of section but to be precise the key parts are chatbots, members, Authorization(API-key), Credits and Usage analytics.

Currently, you can only own up to 5 workspaces but you can be a member of as many as possible workspaces, opening the world of collaboration to developers.

The interactive collaboration feature is still under development as of this being published, so you may face issues when modifying the same chatbot.

Chatbots

On entry, you will be defaulted to chatbot section. On this you can view and create chatbot and much more. Chatbot is the pillar of Sarufi, lets get a bit of overview of it. This is highly digested structure of what you will find into your chatbot.

Taking a look at a structural overview of chatbot  above, you can explicitly see there are two types of chatbots that you can create, namely Flow-based , LLM based  but you also have an option to make an Hybrid Version. Each chatbot type with its core supported functionalities. Visit our documentation to learn more on chatbot features

We make building chatbots as easy as possible. Bring your solution into use within few minutes of ideation.

Members

The idea of workspace is straight forward to get people in a team work together. Currently, members are of two layers namely Admin(Creator) and Invited(Team member). With Admin as high level controller, invited members have limited permissions.

You will find all members of the workspace, depending on your level of privileges you might have allowable actions to perform.

Credits

Workspace as an upgrade of Sarufi introduces a payment plan. Its pay for what you use. You will only be charged per conversations.

Sarufi conversation, this is complete back and forth exchange of info between your user and chatbot. A conversation is a  a complete exchange of Information as  illustrated below.

The cost depends on what engine processes your conversation.  Here is the break down.

On creating your first workspace you will have 2K Tsh of credits.

To top up your account, is straight forward. Navigate to your workspace(On your profile icon>> View your workspace) >> Purchase credits >> Follow instructions

Workspace Usage

In this section you will find all you need to know about your workspace credits usage.  You will have probably 3 sections on usage, namely Overall usage, Chatbot activity and Activity Logs. You will be able to view how usage of your agents grows over time.

To this point we mark this as the end of our walk in your new dashboard. With development in progress expect to find more than highlighted features.

Conclusion

This is the end of our quick walk through Sarufi Dashboard. The Platform keeps evolving increasing support for new functionalities/features. The new dashboard is to enhance collaboration.

"Great software isn't built by individual heroes; it's the result of teams working together, leveraging each other's strengths and covering each other's weaknesses." – John Carmack

Remember those old cell phones that were super heavy and the internet that sounded like a broken robot? Businesses that still use that stuff like outdated computer programs need an update! Today's game-changer is AI chatbots and the prize? Your customers' attention (and their money!).

Consider it: a potential customer has a burning question at 3 am. With an AI chatbot, they get an instant, helpful answer. Your competitor? Radio silence. Who gets the sale? The business that embraced the future, of course!

Like social media marketing dethroned traditional advertising, AI chatbots are revolutionizing customer service. , and those who deploy them on platforms like WhatsApp and social media will conquer the customer experience battleground. Here's why:

WhatsApp: Your Customer's Most Intimate Space

Imagine this: you can have a conversation with your favorite store directly within WhatsApp, your go-to messaging app.  AI chatbots make this a reality.  Customers can ask questions, track orders, or even initiate returns, all within the familiar comfort of WhatsApp. It's a convenient, personalized service that keeps them coming back for more.

Social Media: Where Conversations Already Happen

Social media is a constant buzz of connection.  AI chatbots placed strategically on Facebook Messenger, Instagram, or Twitter can jump right into those conversations.  They can answer product inquiries, schedule appointments, or even provide real-time support during live streams.  It's seamless customer engagement that fosters brand loyalty.

The Power of Integration: A Match Made in Customer Service Heaven

The beauty of AI chatbots on these platforms is their integration.  Data collected through WhatsApp interactions can be used to personalize Facebook Messenger experiences.  Social media comments can be automatically routed to the chatbot for swift resolution.  It's a unified customer service front that ensures no question goes unanswered, no matter the platform.

Beyond WhatsApp and Social Media: The Chatbot Revolution Spreads

While these platforms are prime battlegrounds, the chatbot revolution isn't limited.  Imagine chatbots seamlessly integrated into your website, guiding customers through the buying journey.  Think voice assistants powered by AI, offering hands-free support.  The possibilities are endless.

The Takeaway: Embrace the Chatbot Uprising or Face Extinction

The message is clear: AI chatbots are no passing fad. They're the future of customer service.  By deploying them on platforms like WhatsApp and social media, businesses can create a connected, personalized experience that keeps customers engaged and loyal.  Don't be the dinosaur clinging to outdated methods.  Embrace the chatbot uprising and watch your business thrive in the new era of customer engagement.

We're Nominated for the Tanzania Digital Awards 2024!

We're thrilled to announce that Neurotech Africa has been nominated for the Digital Awards 2023 in the category of Best Startup of the Year!

This is a huge honor for our entire team, and we're incredibly grateful for the recognition. It wouldn't be possible without the dedication and hard work of everyone involved.

There's more exciting news! Our founder and CEO, Kalebu Gwalugano, is also nominated in the category of Best Innovator of the Year.

We'd be so grateful if you could take a moment to vote for Neurotech Africa and Kalebu. Here's how you can do it:

1. Visit the Digital Awards website: https://digitalawards.co.tz/
2. Sign up or Sign in (if you already have an account).
3. Click the "Vote" button.
4. Scroll down to no (7) - Digital Innovation, Section (G) Digital Innovator of the Year category, and click "Vote" for Kalebu Gwalugano.
5. Then, go to section (H) Startup of the Year section and click "Vote" for Neurotech Africa.

Thank you for your incredible support! Every vote counts.

Let's bring these awards home!

E-commerce is booming, but competition is fierce. Businesses are constantly searching for new ways to connect with customers and create a seamless shopping experience. WhatsApp: the messaging platform with over 2 billion users that's poised to revolutionize the way we shop online. Here's why:

A Familiar Friend in a Digital World:

People are already comfortable using WhatsApp to chat with friends and family. This familiarity translates into a lower barrier to entry for businesses. Customers don't need to download a new app or create a new account – they can simply message a familiar number.

Hyper-Personalized Shopping:

WhatsApp fosters a one-on-one connection, unlike any other platform. Businesses can leverage this to personalize the shopping experience. Imagine a customer browsing shoes online. They can send a quick WhatsApp message asking about size availability or requesting a specific picture. This real-time interaction builds trust and fosters a sense of customer service that's unmatched by traditional e-commerce platforms.

The Power of Conversational Commerce:

Gone are the days of static product pages. WhatsApp allows for dynamic, two-way conversations. AI chatbots can be integrated into your WhatsApp business account to handle basic inquiries, recommend products based on past purchases, and even guide customers through the checkout process. These chatbots become tireless salespeople, available 24/7 to answer questions and close deals.

Building Relationships, Not Just Transactions:

WhatsApp goes beyond just selling products. It fosters relationships. Businesses can use broadcast lists to send out special offers, personalized recommendations, and even loyalty program updates. This constant, yet non-intrusive, communication keeps customers engaged and strengthens brand loyalty.

A Global Marketplace in Your Pocket:

WhatsApp transcends geographical boundaries. With its massive user base and global reach, businesses can tap into new markets and connect with international customers with ease.

The Future is Conversational:

The way we interact with technology is shifting towards a more conversational approach. Voice assistants and chatbots are becoming commonplace. WhatsApp, with its already established user base and focus on real-time communication, is perfectly positioned to be at the forefront of this conversational commerce revolution.

So, how can you get started?

• Set up a WhatsApp Business Account: This allows you to create a business profile, manage customer interactions, and utilize features like automated greetings and quick replies.
• Develop a Compelling Chatbot Strategy: Define what tasks you want your chatbot to handle and invest in creating a user-friendly experience. ( If you can't build one, don't worry, Experts from Neurotech Africa will help you build one)
• Personalize the Experience: Use customer data to craft targeted messages and recommendations.
• Focus on Building Relationships: Don't be overly promotional. Use WhatsApp to connect with your customers on a more personal level.

WhatsApp is whispering the future of e-commerce, and with the help of AI chatbots, it will soon be shouting it from the rooftops. Are you ready to listen?

Let's be honest, reaching customers these days feels like trying to herd kittens. Emails get buried, and social media is a constant battle for attention and phone calls? Forget about it!  There's gotta be a better way, right?

Well, there is! And guess what? It's probably already sitting in your pocket – WhatsApp!

This messaging giant boasts over 2 billion monthly users – that's more people than the entire population of North and South America combined!  And guess what they're using it for? Chatting with friends, family, and... wait for it... potentially YOUR business!

Hold on, you might think, "WhatsApp is just for casual chats, right?" Wrong!  It's becoming a game-changer for businesses like yours and mine to connect with customers in a way that's personal, convenient, and crazy effective.  Here's the scoop:

1. It's Like Texting Your Best Friend (But Way More Professional):  People love WhatsApp because it's easy.  Customers can chat with you on their terms, whenever it fits their schedule.  No need to download a new app or create an account – it's already there!  This makes them feel valued and way more likely to engage with your business.

2. Ditch the Annoying Bots and utilize the AI Superhero! Now things get really cool.  Imagine having a super-powered AI assistant working for you 24/7 on WhatsApp.  This is where chatbot technology swoops in to save the day.

Think of it as a tireless teammate who can:

• Answer those same customer questions you get all the time (you know, the ones that make you want to pull your hair out?)
• Process orders in a flash (no more manual data entry!)
• Schedule appointments like a champ (freeing you up for more important stuff)
• Even provide basic customer support (so you can focus on the trickier issues)

This frees you and your team up to focus on what really matters, while still keeping your customers happy as clams.

3. Streamlining Operations? We Got This!  Sick of repetitive tasks slowing you down?  Chatbots can handle those too!  Imagine automating appointment confirmations, order tracking, or even sending out special offers.  This saves you tons of time, reduces errors, and keeps your business running like a well-oiled machine.

4. Building Relationships (and Sales!) That Don't Feel Salesy:   WhatsApp lets you have real conversations with customers. You can send pictures, videos, and even voice messages, making interactions more engaging and less like a robot reading from a script.  This helps build trust and loyalty, which translates to more sales and returning customers – a win-win!

So, How Do We Get This WhatsApp Magic Working for Us?

Don't worry, there are tons of resources available to help your business set up a WhatsApp chatbot technology.  It's actually way easier than you might think!

Think about it: While your competitors are still stuck in the old-school marketing rut, you'll be using the power of WhatsApp and AI to launch your business growth into the stratosphere!  

Don't think twice, start building Your Super-Smart WhatsApp AI Chatbot with Sarufi & Fuel Your Business Success!

Click the Link  Sarufi to explore the Magic of Artificial Intelligence Chatbots.

Great news to share from last week's Generative AI MeetUp and Hackathon hosted by us Neurotech Africa !

The event, which focused on using Swahili AI Model built by Dr. Michael S. Mollel, PHD  to tackle real-world problems, brought together a fantastic group of attendees - over 50! ‍Big thanks to all who participated!

Here are some of the amazing things that came out of the hackathon:

Team NURU under the leadership of Fredy German Mgimba  took the top spot with their innovative LLM that generates Swahili programming code snippets for developers. This is a game-changer for Swahili-speaking programmers!

Team Maudhui AI  under the leadership of Annagrace Malamsha , Edgar Gulay , Shaaban Daudi, Godson Ntungi and  Mgasa Lucas  impressed everyone with their model that transforms Swahili text into visual content. Think "show, don't tell" on a whole new level!

Team Sheria under the leadership of Gabriel Minzemalulu  and Adam Katani developed a super helpful LLM chatbot that makes Swahili legal information more accessible. Huge win for the Swahili legal community!

A big shoutout to the Mentors, Judges , participants winning teams and everyone who participated!

This hackathon is a great example of how people in the AI Community , academia and developers can come together to build powerful AI solutions in Swahili.

#SwahiliAI #AIforGood #NeurotechAfrica

The world is inherently uncertain, characterized by imprecise measurements, ambiguous definitions, and incomplete knowledge. Uncertainty pervades various aspects of our lives, from everyday facts like temperature readings to complex decisions like evaluating a president's performance or identifying potential hazards. Despite this uncertainty, humans often make successful decisions, relying on heuristic reasoning and empirical observations.

Representation of Uncertainty

To effectively address uncertainty, various models have been developed. Two prominent models are the non-deterministic model and the probabilistic model. The non-deterministic model represents uncertainty through a set of possible values or scenarios, while the probabilistic model assigns probabilities to different outcomes. Each model has its application domain and is suited to different types of uncertainty.

Sources of Uncertainty

Uncertainty arises from various sources, including uncertain data and uncertain knowledge. Uncertain data may be missing, unreliable, or ambiguous, while uncertain knowledge may stem from incomplete understanding or probabilistic effects. Representing and reasoning with uncertain information pose challenges, especially when the underlying system's complexity limits our ability to make accurate predictions or inferences.

Reasoning Under Uncertainty

Despite uncertainty, humans employ various strategies for reasoning and decision-making. These include heuristic approaches, empirical associations based on experience, and probabilistic reasoning using objective or subjective probabilities. Rational decision-making involves assessing the probabilities and utilities of different outcomes to select the action with the highest expected utility, following the principle of Maximum Expected Utility.

Some Relevant Factors

In addressing uncertainty, several factors must be considered, including the expressiveness of representation, comprehensibility, correctness, computational complexity, and reproducibility. Representations must adequately capture human concepts and confidence levels, facilitate reasoning, and produce meaningful results efficiently and consistently.

Basics of Probability Theory

Probability theory provides a mathematical framework for processing uncertain information. It involves defining a sample space of possible events and assigning probabilities to these events. Probabilities range from 0 to 1, with the total probability of the sample space being 1. Probabilistic reasoning allows for the calculation of compound probabilities, conditional probabilities, and joint probabilities, essential for making informed decisions under uncertainty.

Approaches to Handle Uncertainty

Several approaches address uncertainty, including Bayesian approaches, Dempster-Shafer theory, hidden Markov models, certainty factors, and fuzzy logic. Bayesian methods derive probabilities based on observed evidence and prior beliefs, while Dempster-Shafer theory combines evidence using mass probability functions. Hidden Markov models deal with hidden states, while certainty factors express confidence in hypotheses. Fuzzy logic extends traditional binary logic to handle degrees of membership in sets, allowing for more flexible reasoning.
In Summary Let's delve into each approach in details:

Certainly! Let's delve into each approach in detail using the provided notes:

1. Bayesian Approaches:

Bayesian approaches utilize probabilities to represent uncertainty and make decisions based on observed evidence and prior beliefs.

Process:

• They derive probabilities of events or hypotheses given observed evidence using Bayes' theorem or its variants.
• These approaches involve updating prior beliefs with new evidence to obtain posterior probabilities.

Application:

• Bayesian methods are widely used in various domains such as decision-making, pattern recognition, and machine learning.

Advantages:

• They provide a sound theoretical foundation for reasoning under uncertainty.
• Bayesian methods offer a well-defined semantics for decision-making.

Challenges:

• They require substantial amounts of probability data, which may not always be available.
• Subjective evidence might not always be reliable, leading to potential biases in decision-making.

2. Dempster-Shafer Theory:

Dempster-Shafer theory is a mathematical framework for reasoning under uncertainty, focusing on combining evidence from different sources.

Process:

• It employs mass probability functions to represent belief or uncertainty associated with different propositions.
• These mass probability functions assign values from 0 to 1 to elements in a frame of discernment, indicating the degree of belief.
• Dempster's rule of combination allows for the combination of evidence from multiple sources.

Application:

• Dempster-Shafer theory finds applications in fields such as decision support systems, fault diagnosis, and risk assessment.

Advantages:

• It offers a clear and rigorous foundation for reasoning under uncertainty.
• Dempster-Shafer theory enables the expression of confidence intervals, providing insights into the certainty about certainty.

Challenges:

• Determining mass probability functions can be non-intuitive and computationally intensive.
• Combining non-independent evidence may yield counterintuitive results due to normalization issues.

3. Hidden Markov Models (HMMs):

Hidden Markov models are probabilistic models used to model sequences of observable events when the underlying states are not directly observable.

Process:

• HMMs consist of a set of hidden states, observable events, transition probabilities between states, and emission probabilities for each event.
• They employ the Viterbi algorithm or the forward-backward algorithm for inference and learning.

Application:

• HMMs are extensively used in speech recognition, natural language processing, bioinformatics, and financial modeling.

Advantages:

• They can capture complex temporal dependencies and handle sequences of observations effectively.
• HMMs allow for learning model parameters from data, enabling adaptation to different scenarios.

Challenges:

• Determining the optimal number of states and model parameters can be challenging.
• HMMs may suffer from the "curse of dimensionality" when dealing with large state spaces.

4. Certainty Factors:

Certainty factors are used to express the degree of belief or confidence in a hypothesis given observed evidence.

Process:

• They denote the belief or disbelief in a hypothesis based on the presence or absence of evidence.
• Certainty factors range between -1 (denial of the hypothesis) and 1 (confirmation of the hypothesis).

Application:

• Certainty factors are commonly employed in expert systems, diagnostic systems, and decision support systems.

Advantages:

• They offer a simple implementation and provide a way to model human experts' beliefs effectively.
• Certainty factors allow for the expression of both belief and disbelief in hypotheses.

Challenges:

• Certainty factors may require adjustments or updates when new evidence becomes available.
• They may not always align with probabilistic reasoning, leading to potential inconsistencies.

5. Fuzzy Logic:

Fuzzy logic extends traditional binary logic to handle degrees of membership in sets, allowing for more flexible reasoning.

Process:

• It represents uncertainty by assigning degrees of membership to elements in sets using fuzzy membership functions.
• Fuzzy logic employs fuzzy rules to infer conclusions from fuzzy inputs and outputs.

Application:

• Fuzzy logic finds applications in control systems, decision support systems, and pattern recognition.

Advantages:

• It provides a formal framework for representing and reasoning with uncertain or imprecise information.
• Fuzzy logic allows for a more intuitive and human-like representation of uncertainty.

Challenges:

• Defining appropriate membership functions and fuzzy rules can be subjective and require domain expertise.
• Fuzzy logic systems may not always produce consistent or interpretable results, especially in complex scenarios.

Credits : UDSM AI Gitbook

Recently, I read a blog post about customizing APIs from Gemini Models, but when I tried following the instructions, everything got stuck at localhost:5000. Basically, my apps were only visible on my computer. So, I went on a quest to figure out how to make it accessible to everyone. That's when I learned about deploying Flask apps on a Digital Ocean droplet. This guide is like a map to help you do the same, so your projects don't get stuck at localhost:5000 either. Let's share your awesome creations with the world! ✨ It's time to unleash them onto the global stage by mastering the art of deploying Flask applications on a Digital Ocean droplet or any Ubuntu Server.

Step by step  guide to deploying Flask app in digital ocean droplet using gunicorn and nginx.

Things we are going to cover

1. Creating digital ocean droplet
2. Preparing environment
3. Actual deployment guide

Creating digital ocean droplet

Go to digital ocean and create an account if you don't have one. here is the link
✨ Digital Ocean 🎉 ~ This is a referral link, you will get $200 credit for 60 days. so no more excuses to why your projects are not deployed.

After creating an account, click on the create button and select droplets. You will be presented with a list of options. Select the Ubuntu 20.04 LTS. Choose the plan of your preference. You can choose any data center region you want. I usually choose the one closest to me.

Choose the authentication method. SSH keys are the best but for this guide, we are going to use a password. You can always add SSH keys later.

if you are a windows user get yourself a virtual box and install Ubuntu. or use WSL 😂.

Preparing environment

Now that we have our droplet up and running, let's prepare our environment.
connect to your droplet using ssh.

ssh root@your_droplet_ip

Provide your password and you are in.

Update and upgrade

sudo apt update
sudo apt install python3-pip python3-dev build-essential libssl-dev libffi-dev python3-setuptools

the command sudo apt update refreshes the list of available software packages on your system, ensuring that it has the latest information from the repositories. Following that, sudo apt install python3-pip python3-dev build-essential libssl-dev libffi-dev python3-setuptools installs essential tools and dependencies for Python development. This includes the Python 3 package manager (python3-pip), development headers for Python (python3-dev), fundamental build tools (build-essential), as well as libraries for SSL and FFI (libssl-dev and libffi-dev), and the Python package distribution tools (python3-setuptools).

Create a virtual environment

sudo apt install python3-venv

Create a directory for your project and navigate to it.

mkdir apps
cd apps

Create a virtual environment

python3 -m venv venv

Activate the virtual environment

source venv/bin/activate

Clone your project

let's call our project flask_app

git clone your_project_url.git
cd flask_app

Install project dependencies

pip install -r flask_app/requirements.txt

now that we have your project up and running, let's run it and see if everything is working as expected.
first lets allow the port we are going to use.

sudo ufw allow 5000

run the app

python app.py

if everything is working as expected, you should be able to access your app using your droplet ip and port 5000.
something like this http://your_droplet_ip:5000

Actual deployment guide

Create WSGI entry point

Create a file called wsgi.py in your project root directory.
or just copy app.py to wsgi.py

cp app.py wsgi.py

Configure Gunicorn

Safe check if gunicorn is installed

gunicorn --version

if not installed install it using pip

pip install gunicorn

try running your app using gunicorn

gunicorn --bind 0.0.0.0:5000 wsgi:app

Check your app using your droplet ip and port 5000. something like this http://your_droplet_ip:5000

if everything is working as expected, let's move to the next step.

Create a systemd service file

Create a systemd service file for gunicorn, this will allow gunicorn to automatically start on boot.
first deactivate your virtual environment

deactivate

Then create a file called flask_app.service in /etc/systemd/system/ directory.

sudo nano /etc/systemd/system/flask_app.service

Add the following configuration to the file

[Unit]
Description=Gunicorn instance to serve flask_app
After=network.target

[Service]
User=root
Group=www-data
WorkingDirectory=/root/apps/flask_app
Environment="PATH=/root/apps/venv/bin"
ExecStart=/root/apps/venv/bin/gunicorn --workers 3 --bind 0.0.0.0:5000 -m 777 wsgi:app

[Install]
WantedBy=multi-user.target

After creating the file, start the gunicorn service and enable it to start on boot.

sudo systemctl start flask_app
sudo systemctl enable flask_app

Check the status of the service to make sure it's running without any issues.

sudo systemctl status flask_app

example output

Configure Nginx to Proxy Requests

Install Nginx

sudo apt install nginx

Create a new server block configuration file in Nginx's sites-available directory.

sudo nano /etc/nginx/sites-available/flask_app

Add the following configuration to the file. Replace your_domain_or_ip with your actual domain name or IP address.

server {
    listen 80;
    server_name 143.198.232.28;

    location / {
        proxy_pass https://143.198.232.28:5000;
    }
}

Create a symbolic link to the file in the sites-enabled directory.

sudo ln -s /etc/nginx/sites-available/flask-app /etc/nginx/sites-enabled

Test your Nginx configuration for syntax errors.

sudo nginx -t

you should see something like this

nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

If the test is successful, restart Nginx.

sudo systemctl restart nginx

Remember we allowed port 5000 earlier, now we can remove it.

sudo ufw delete allow 5000

Now you should be able to access your app using your domain name or IP address without the port number. something like this http://your_droplet_ip

Secure your app with SSL

Install certbot

sudo apt install certbot python3-certbot-nginx

Obtain a free SSL certificate for your domain using certbot if you have a domain.

sudo certbot --nginx -d your_domain_or_ip

Certbot will ask you to provide an email address for lost key recovery and notices, and to agree to the terms of service. After doing so, certbot will communicate with the Let's Encrypt server, then run a challenge to verify that you control the domain you're requesting a certificate for.

When that's finished, certbot will ask how you'd like to configure your HTTPS settings.

or you can use openssl to generate a self-signed certificate.

sudo openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout /etc/ssl/private/flask_app.key -out /etc/ssl/certs/flask_app.crt

Create a new server block configuration file in Nginx's sites-available directory.

sudo nano /etc/nginx/sites-available/flask_app

Add the following configuration to the file. Replace your_domain_or_ip with your actual domain name or IP address.

server {
    listen 80;
    server_name

    location / {
        proxy_pass https://your_domain_or_ip;
    }
}

server {
    listen 443 ssl;
    server_name your_domain_or_ip;

    ssl_certificate /etc/ssl/certs/nginx-selfsigned.crt;
    ssl_certificate_key /etc/ssl/private/nginx-selfsigned.key;

    location / {
        proxy_pass https://your_domain_or_ip;
    }
}

This configuration tells Nginx to listen on both port 80 (HTTP) and port 443 (HTTPS). It uses the self-signed certificate and private key that you created.

After updating the Nginx configuration, remember to test the configuration and reload or restart Nginx:

sudo nginx -t
sudo systemctl reload nginx

The nginx -t command checks the configuration for syntax errors. The systemctl reload nginx command reloads the Nginx configuration without interrupting currently connected clients.

Please note that because the certificate is self-signed, browsers will show a warning to users that the site is not secure. Users will need to manually accept the risk and proceed to the site.

Conclusion

Hopefully with this template guide, you were able to deploy your flask app in a digital ocean droplet. Your projects are way too precious to be running on localhost. Deploy them and share them with the world. If you have any questions or suggestions, feel free to reach out help is everywhere. ✨

Flask, a lightweight and flexible web framework for Python, provides a simple and extensible structure for building web applications. As your project grows, organizing your code becomes crucial for maintainability. One effective way to structure your Flask project is by using multiple apps. In this blog post, we'll explore how to register and organize multiple apps within a Flask project.

Why Multiple Apps?

Breaking down a monolithic Flask application into smaller, modular apps offers several advantages:

Modularity: Each app can focus on specific functionality, making it easier to maintain and understand.

Reusability: Apps can be reused across projects, promoting code consistency.

Scalability: Separating concerns allows for easier scaling as your project expands.

Getting Started

You can get a template flask API app at  Aida (Flask Rest API) template

GitHub - Aida-LLC/Flask-Rest: Flask-Rest is a lightweight and flexible REST API project built using the Flask web framework. It provides a solid foundation for developing RESTful web services, making it easy to create, update, and retrieve data through HTTP requests.

Flask-Rest is a lightweight and flexible REST API project built using the Flask web framework. It provides a solid foundation for developing RESTful web services, making it easy to create, update, ...

GitHubAida-LLC

Let's assume you have a basic Flask project with the following structure:

/my_project
    /app
        /static
        /templates
        __init__.py
        routes.py
    config.py
    run.py

Now, let's create a new app called admin and register it within the project.

Step 1: Create the New App

Create a folder for the new app within the project:

/my_project
    /app
        /static
        /templates
        __init__.py
        routes.py
    /admin
        __init__.py
        routes.py
    config.py
    run.py

Step 2: Define Routes for the New App

Define the routes for the new app in admin/routes.py:

# admin/routes.py

from flask import Blueprint

admin_bp = Blueprint('admin', __name__)

@admin_bp.route('/dashboard')
def dashboard():
    return 'Admin Dashboard'

Step 3: Register the New App

In admin/__init__.py, create an instance of Blueprint and register it with the main Flask app:

# admin/__init__.py

from flask import Blueprint

admin_bp = Blueprint('admin', __name__)

# Import routes to register them
from . import routes

def init_app(app):
    app.register_blueprint(admin_bp, url_prefix='/admin')

Step 4: Update the Main App

In the main __init__.py file, update it to initialize the new app:

# app/__init__.py

from flask import Flask
from .admin import init_app as init_admin_app

app = Flask(__name__)


# Initialize the admin app
init_admin_app(app)

Now, you have successfully registered a new app within your Flask project.

final thoughts ...

Organizing your Flask project with multiple apps allows for a cleaner and more modular codebase. Each app can encapsulate specific functionality, making the entire project more maintainable and scalable. Following these steps, you can easily extend your project with new apps, ensuring a structured and organized codebase.

Happy coding!

Can we spread the knowledge and enthusiasm for LLMs far and wide!

The goal here is to put knowledge into practice.

On the 8th of February, Tanzania AI Community hosted an extraordinary event centered on LLM (Large Language Models). If you missed out we've got you covered. Here's a rundown of the discussions we had.

First off, let's talk about the heart of the matter. What were the main topics on the table?

The event was expertly host Victor Oldensand, who shed light on the application of retrieval-augmented generation to enhance the competence of generative AI in supporting Tanzanian educators. I want to clarify that I don't claim ownership of the valuable insights he provided, and any mistakes in this article are solely mine, not his.

Let me share what I grasped from the presenter and how I attempted to translate that understanding into action through coding challenges and implementations. A heartfelt thank you to Victor for the wealth of experience and knowledge he shared with us. It was truly invaluable.

let's kickstart our summary by focusing on these key areas, just as our discussions unfolded.

Large Language Models(LLMs)
Retrieval Augmented Generation (RAG)
Evaluating RAG systems

Topics up there, are what was discussed, but here we'll skip some

AI in Education
Challenges and Ethics

and dive straight into the coding implementation of what was discussed. Let's roll up our sleeves and get coding!

what are Large Language models?

Large language models (LLMs) are deep learning algorithms that can recognize, summarize, translate, predict, and generate content using very large datasets. These models are based on transformer architecture and are trained using massive textual datasets, enabling them to understand and generate human language. Some examples of popular large language models include GPT-3 and GPT-4 from OpenAI, LLaMA from Meta, and PaLM2 from Google. These models have the shown potential to disrupt various industries and have been adopted for a wide range of applications.

What is Retrieval Augmented Generation (RAG)?

Retrieval-augmented generation (RAG) is a technique for enhancing the accuracy and reliability of generative AI models by retrieving facts from an external knowledge base to ground large language models (LLMs) on the most accurate, up-to-date information. It allows LLMs to build on a specialized body of knowledge to answer questions more accurately and provides users with insight into LLMs' generative process. RAG involves two phases: retrieval and content generation, and it extends the capabilities of LLMs to specific domains or an organization's specialized knowledge. The technique is used to optimize the output of LLMs so that they reference a knowledge base outside of their training data sources. RAG is implemented to ensure that the model has access to the most current, reliable facts and that users have access to the model’s sources, ensuring that its claims can be checked for accuracy and ultimately trusted. It also allows models to cite sources, like footnotes in a research paper, so users can check any claims, which builds trust. The technique can be used by nearly any LLM to improve the quality of LLM-generated content.

So how to Build an LLM application with RAG?

We will build a simple LLM application in Python using the LangChain library. Our RAG application will expand an LLM's knowledge using private data. In this case, it will be a PDF file containing some text. A doc on Ultrasonics in Physics.

1. Prerequisites

At the very beginning, we must install all required modules, that our application will use. Let’s write this command in the terminal in the project directory.

pip install langchain-community==0.0.11 pypdf==3.17.4 langchain==0.1.0 python-dotenv==1.0.0 langchain-openai==0.0.2.post1 faiss-cpu==1.7.4 tiktoken==0.5.2 langchainhub==0.1.14

Then create a ‘data’ directory and place the PDF file in it.  We must also create a main.py file in the project directory, where we will store the whole code of our application.

The main file will look like this.

def main():
  print("Everything will written over here!")

if __name__ == "__main__": 
  main()

2. Load the PDF file into the application.

We will use a document loader provided by LangChain called PyPDFLoader.

from langchain_community.document_loaders import PyPDFLoader

pdf_path = "./data/Ultrasonics.pdf"

def main():
  loader = PyPDFLoader(file_path=pdf_path)
  documents = loader.load()
  print(documents) 

if __name__ == "__main__": 
  main()

First, we should create an instance of the PyPDFLoader object where we pass the path to our file. The next step is to simply call the load function on this object and save the loaded file in the documents variable. It will be an array consisting of Document objects, where each of these objects is a representation of one page of our file.

The print() function should output an array similar to this:

[Document(page_content='[...]', metadata={'source': pdf_path, page: 1}), Document(page_content='[...]', metadata={'source': pdf_path, page: 2}), ...]

3. Splitting document into smaller chunks

We don’t want to send a whole document as a context with our query to the LLM. To split the document, we will use a class provided by LangChain called CharacterTextSplitter, which we can import from the Langchain library:

from langchain.text_splitter import CharacterTextSplitter

Then we can create an instance of it and call the split_documents() function, passing our loaded documents as a parameter.

def main():
  loader = PyPDFLoader(file_path=pdf_path) 
  documents = loader.load() 
  text_splitter = CharacterTextSplitter( chunk_size=1000, chunk_overlap=50, separator="\n" ) 
  docs = text_splitter.split_documents(documents)

Let's briefly describe what's going on here.

First, we are creating a CharacterTextSplitter object, which takes several parameters:

• chunk_size - defines the maximum size of a single chunk measured in tokens.
• chunk_overlap - defines the size of overlap between chunks. This helps to preserve the meaning of the split text by ensuring that chunks are not split in a way that would distort their meaning.
• separator - defines the separator that will be used to delineate our chunks.

In the docs variable, we will get an array of Document objects - the same as from the load() function of the PyPDFLoader class. But this time, this array will contain more elements because we have split them.

4. Prepare environment variables and API Key to store it there

​​The next step will be converting these chunks into numeric vectors and storing them in a vector database. This process is called embedding, we will talk about embedding next time, so we won't go into detail about it now.

For the embedding process, we need an external embedding model. We will use OpenAI embeddings for this purpose. To do that, we have to generate an OpenAI API key.
But before that, we have to create a .env file where we will store this key.

Now, we need to create an account on the platform.openai.com/docs/overview page.  Afterward, we should generate an API key on the platform.openai.com/api-keys page by creating a new secret key.

Copy the secret key and paste it into the .env file like this:

OPENAI_API_KEY=your_key

paste your openai key on "your_key"

Okay, let’s load environment variables into our project by importing the load_dotenv function:

from dotenv import load_dotenv

And call it at the very beginning of the main function:

def main(): 
	load_dotenv()
	loader = PyPDFLoader(file_path=pdf_path) 
	documents = loader.load() 
	text_splitter = CharacterTextSplitter( chunk_size=1000, chunk_overlap=50, separator="\n" ) 
	docs = text_splitter.split_documents(documents)

5. Implementing the embedding process

First, we have to import the OpenAIEmbeddings class:

from langchain_openai import OpenAIEmbeddings

Then we should create an instance of this class. Let’s assign it to the 'embeddings' variable like this:

embeddings = OpenAIEmbeddings()

6. Setting up local vector database - FAISS

We have loaded and prepared our file, and we have also created an object instance for the embedding model. We are now ready to transform our chunks into numeric vectors and save them in a vector database. We will keep all our data locally using the FAISS vector database. Facebook AI Similarity Search (Faiss) is a tool designed by Facebook AI for effective similarity search and clustering of dense vectors.

First, we need to import the FAISS instance:

from langchain_community.vectorstores.faiss import FAISS

And implement the process of converting and saving embeddings:

def main(): 
	load_dotenv() 
	loader = PyPDFLoader(file_path=pdf_path) 
	documents = loader.load() 
	text_splitter = CharacterTextSplitter( chunk_size=1000, chunk_overlap=50, separator="\n" ) 
	docs = text_splitter.split_documents(documents) 
	embeddings = OpenAIEmbeddings() 
	vectorstore = FAISS.from_documents(docs, embeddings)    
	vectorstore.save_local("vector_db")

We have added two lines to our code. The first line takes our split chunks (docs) and the embeddings model to convert the chunks from text to numeric vectors. After that, we are saving the converted data locally in the 'vector_db' directory.

7. Creating a prompt

For preparing a prompt we will use a 'langchain' hub. We will pull a prompt called 'langchain-ai/retrieval-qa-chat' from there. This prompt is specially designed for our case, allowing us to ask the model about things from the provided context. Under the hood, the prompt looks like this:

Answer any use questions based solely on the context below:
<context> 
{context}
</context>

Let’s import a hub from the 'langchain' library:

from langchain import hub

Then, simply use the 'pull()' function to retrieve this prompt from the hub and store it in a variable:

retrieval_qa_chat_prompt = hub.pull("langchain-ai/retrieval-qa-chat")

8. Setting up a large language model

Great. The next thing we'll need is a large language model - in our case, it will be one of the OpenAI models. Again, we need an OpenAI key but we have already set up it along with the embeddings, so we don't need to do it again.

Let's go ahead and import the model:

from langchain_openai import ChatOpenAI, OpenAIEmbeddings

And assign it to a variable in our main function:

llm = ChatOpenAI()

9. Retrieve context data from the database

Okay, we have finished preparing the vector database, embeddings, and LLM (large language model). Now, we need to connect everything using chains. We will need two types of chains provided by 'langchain' for that.

The first one is the 'create_stuff_documents_chain,' which we need to import from the 'langchain' library:

from langchain.chains.combine_documents import create_stuff_documents_chain

Next, pass our large language model (LLM) and prompt to it.

combine_docs_chain = create_stuff_documents_chain(llm, retrieval_qa_chat_prompt)

This function returns a Runnable object, which requires a context parameter. Running it will look like this:

combine_docs_chain.invoke({"context": docs, "input": "What is piezo effect?"})

10. Retrieve only the relevant data as a context

Generally, it will work, we need to pass only the information related to our query as the context. We will achieve this by combining this chain with another one, which will retrieve only the chunks important to us from the database and automatically add them as context to the prompt.

Let's import that chain from the 'langchain' library:

from langchain.chains import create_retrieval_chain 

First, we need to prepare our database as a retriever, which will enable semantic search for the chunks that are relevant to our query.

retriever = FAISS.load_local("vector_db", embeddings).as_retriever()

So, we load our directory where we store the chunks converted to vectors and pass it to an embeddings function. In the end, we return it as a retriever.

Now, we can combine our chains:

retrieval_chain = create_retrieval_chain(retriever, combine_docs_chain)

Under the hood, it will retrieve relevant chunks from the database and add them to our prompt as context. All we have to do now is invoke this chain with our query as an input parameter:

response = retrieval_chain.invoke({"input": "What is piezo effect?"})

As a response, we will receive an object with three variables:

• input - our query;
• context - an array of documents (chunks) that we have passed as context to the prompt;
• answer - the answer to our query generated by the large language model (LLM).

Let’s print out the "answer" property:

print(response["answer"])

Our printed answer looks as follows:

The piezo effect is a phenomenon in which certain materials, such as quartz, tourmaline, and Rochelle salt, generate an electric charge when subjected to pressure or mechanical stress. This means that if pressure is applied to one pair of opposite faces of a crystal, electric charge develops on the other pair of opposite faces. The piezo effect is used in piezo-electric generators or oscillators to produce ultrasonic waves.

Looks pretty nice :)

10. You’ve made it! Our LLM app is ready

We have extended the knowledge base of the LLM model with data from an Ultrasonic.pdf file. The model is now able to answer our questions based on the context that we have provided in the prompt.

Below is the whole piece of code.

from dotenv import load_dotenv
from langchain import hub
from langchain.chains import create_retrieval_chain
from langchain.chains.combine_documents import create_stuff_documents_chain
from langchain_community.document_loaders import PyPDFLoader
from langchain.text_splitter import CharacterTextSplitter
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_community.vectorstores.faiss import FAISS

pdf_path = "./data/Ultrasonics.pdf"


def main():
    load_dotenv()

    loader = PyPDFLoader(file_path=pdf_path)
    documents = loader.load()

    text_splitter = CharacterTextSplitter(
        chunk_size=1000, chunk_overlap=50, separator="\n"
    )
    docs = text_splitter.split_documents(documents)

    embeddings = OpenAIEmbeddings()

    vectorstore = FAISS.from_documents(docs, embeddings)
    vectorstore.save_local("vector_db")

    retrieval_qa_chat_prompt = hub.pull("langchain-ai/retrieval-qa-chat")

    llm = ChatOpenAI()

    combine_docs_chain = create_stuff_documents_chain(llm, retrieval_qa_chat_prompt)

    retriever = FAISS.load_local("vector_db", embeddings).as_retriever()
    retrieval_chain = create_retrieval_chain(retriever, combine_docs_chain)

    response = retrieval_chain.invoke(
        {"input": "What is piezo effect"}
    )

    print(response["answer"])


if __name__ == "__main__":
    main()

11: More Tips.

● Data pipeline for RAG try (LlammaIndex)

● Vector database for rapid prototyping try (ChromaDB)

● And there are many open source models found on Hugging Face

● TruLens for RAG evaluation

Well, let me tell you,  We delved into various aspects of LLMs and the RAG concept, exploring its potential. Even if you couldn't make it to the event, don't worry – we've got some insightful nuggets to share.

Stay tuned as we unpack the essence of our discussions, providing valuable insights for AI enthusiasts, whatever place you will be, or anywhere else in Tanzania just build and that's what I was inspired to share.

I can't wait to see what you are building next.

For any feedback and chat, let's connect: Mgasa Lucas

Until next time, stay safe.

In the dynamic and broad field of artificial intelligence, the UDSM AI Community continues to be a fostering place of innovation, exploration, and collaborative learning. In our latest session, we embarked on an exciting journey into the realm of natural language processing, specifically focusing on Swahili news classification using Long Short-Term Memory (LSTM) networks.

Our collective attempt is not merely a technical quest but a proof to our commitment to pushing the boundaries of AI understanding. And we chose to go with Swahili, a language rich in history and culture, to serves as our medium to explore how we can understand text (news) classification, demonstrating how advanced techniques can unravel meaningful insights from diverse sources.

Session Objective

Our main goal in this session was twofold. First, we wanted to walk you through a real hands-on activity, neatly packed into a Jupyter notebook. This activity is all about using LSTMs to explore how we can use different tokenizers with Swahili text.

Second, we want this to be a space where everyone can join in. We're all about teamwork here. So, we're encouraging you to jump into the code, ask questions, and share your thoughts. Together, we're going to get better at understanding how to play with tokenizers and make sense of the text using our NLP skills.

As we dive into the technical bits, remember, it's not just about the code; it's about growing together, helping each other, and making our AI community even more awesome.

Technical Implementation

In this technical implementation, we explore the process of Swahili news classification using Long Short-Term Memory (LSTM) networks. The project is a collaborative effort within the UDSM AI Community, aiming to showcase effective Swahili news classification techniques to the community members. The focal point of the session was a Jupyter notebook that encapsulated a hands-on technical activity, specifically implementing a Swahili news classification model. This showcased cutting-edge technologies and methodologies in natural language processing. The code was carefully made to correctly classify Swahili news articles, demonstrating best practices in text classification within the field of machine learning.

The session encouraged everyone to check out the Jupyter notebook and understand the code. We'll talk about specific parts of the code here, explaining important methods and steps. Here are the things we did: -

1. Importing Libraries

The journey into Swahili news classification began with the importation of essential libraries. This ensured that the tools needed for data manipulation and model construction are at our fingertips.

# Import necessary libraries
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.preprocessing import OneHotEncoder

from keras.models import Sequential
from keras.layers import Embedding, LSTM, Dense
from keras.preprocessing.text import Tokenizer
from keras.preprocessing.sequence import pad_sequences

2. Loading Datasets

To lay the groundwork for our Swahili news classification project, we load the dataset from a CSV file. The dataset, sourced from various Swahili news websites, will be our playground for training and testing the LSTM model

# Load your dataset
data_path = 'data/SwahiliNewsClassificationDataset.csv'
df = pd.read_csv(data_path)

3. Data Preprocessing

Before feeding the data into the model, several preprocessing steps are applied.

A: Normalising Data

The first step in preparing our dataset involves normalising the textual data. This includes removing punctuation, numbers, special characters, stop words, and lemmatising words. The result is a clean and standardised text column.

import re
def normalize_text(text):
    # Remove punctuation, numbers, and special characters
    text = re.sub(r'[^a-zA-Z\s]', '', text)
    # Convert to lowercase
    text = text.lower()
    return text

# Normalize the text column
df['Text'] = df['content'].apply(normalize_text)

texts = df['Text'].values
labels = df['category'].values

texts[0], labels[0]

B: Converting Labels to Numerical Formats

With the textual data normalised, the next phase is converting the categorical labels into numerical formats. This facilitates the use of these labels in our LSTM model.

# one hot encode the labels
encoder = OneHotEncoder(sparse=False)
labels = encoder.fit_transform(labels.reshape(-1, 1))

encoder.categories_

4. Splitting the Dataset

To ensure the robustness of our LSTM model, we split the dataset into training and testing sets. This segregation allows us to train the model on one subset and evaluate its performance on another.

# Split the dataset into training and testing sets
train_texts, test_texts, train_labels, test_labels = train_test_split(texts, labels, test_size=0.2, random_state=42)

5. Tokenising and Padding Sequences

In this critical phase, we tokenise the words and pad the sequences to prepare the data for the LSTM model. The tokenisation process involves converting words into numerical values, while padding ensures uniformity in the length of our sequences.

max_words = 1000
max_len = 200

tokenizer = Tokenizer(num_words=max_words)
tokenizer.fit_on_texts(train_texts)

train_sequences = tokenizer.texts_to_sequences(train_texts)
test_sequences = tokenizer.texts_to_sequences(test_texts)

train_data = pad_sequences(train_sequences, maxlen=max_len)
test_data = pad_sequences(test_sequences, maxlen=max_len)

train_data[0].shape, train_labels[0].shape

6. Building the Model

The heart of our Swahili news classification project lies in the construction of the LSTM model. With layers of embedding, LSTM, and dense structures, we compile the model to enable its training on our preprocessed data.

embedding_dim = 50  # Adjust based on your preferences

model = Sequential()
model.add(Embedding(input_dim=max_words, output_dim=embedding_dim, input_length=max_len))
model.add(LSTM(100))
model.add(Dense(6, activation='softmax'))


# Compile the model
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

batch_size = 32
epochs = 10

history = model.fit(train_data, train_labels, validation_split=0.2, batch_size=batch_size, epochs=epochs)

# plot loss and accuracy
import matplotlib.pyplot as plt
plt.plot(history.history['loss'], label='train')
plt.plot(history.history['val_loss'], label='test')
plt.legend()
plt.show()

plt.plot(history.history['accuracy'], label='train')
plt.plot(history.history['val_accuracy'], label='test')
plt.legend()
plt.show()

# evaluate the model
loss, accuracy = model.evaluate(test_data, test_labels, verbose=0)
print('Accuracy: %f' % (accuracy*100))

# save the model
model.save('models/starter_swahili_news_classification_model.h5')

7. Inferencing the Model

As we conclude our journey, we put our trained model to the test by inferring its predictions on a randomly selected Swahili news headline. The process involves pre-processing the input text and utilising the model to make predictions.

# pre-process for inference
def pre_process(tokenizer, max_len, input_text):
    input_sequence = tokenizer.texts_to_sequences([input_text])
    input_data = pad_sequences(input_sequence, maxlen=max_len)
    return input_data

def classify_news(model, tokenizer, encoder, max_len, input_text):
    input_data = pre_process(tokenizer, max_len, input_text)
    pred = model.predict(input_data)
    # for each input sample, the model returns a vector of probabilities
    # return all classes with their corresponding probabilities
    result_dict = {}

    for i, category in enumerate(encoder.categories_[0]):
        result_dict[category] = str(round(pred[0][i] * 100, 2))+'%'

    highest_prob = max(result_dict, key=result_dict.get)

    return (result_dict, highest_prob)

# pick a random news headline from df
news_ = df.sample(1)

news_headline = news_['Text'].values[0]
news_category = news_['category'].values[0]

result_dict, classified_label = classify_news(model, tokenizer, encoder, max_len, news_headline)

print(f'News headline: {news_headline}')
print(f'Actual category: {news_category}')
print(f'Predicted category: {classified_label}')
print(f'Confidence scores: {result_dict}')

Challenges Encountered

Despite our collective efforts in the session, we ran into some tricky situations. The Swahili language posed a unique challenge due to its complexity, and there wasn't much research available on how to break down its words. We had to rely on methods designed for English, which may not be the best fit for Swahili. Additionally, finding information tailored to the specific structure and rules of Swahili proved to be quite difficult. Nevertheless, our community faced these challenges head-on. Instead of seeing them as roadblocks, we turned them into opportunities to learn and improve. Our shared determination and collaborative spirit continue to shape a supportive and dynamic learning environment within the UDSM AI Community.

Outcomes

As a result of our collective efforts, participants gained valuable insights into tokenisation and various tokenisation methods available. The session served as a rich learning experience, expanding our understanding of how to break down and process words effectively.

Moreover, after training the model, we achieved a notable milestone with a maximum accuracy of 83.78%. This success reflects the effectiveness of our collaborative exploration and dedication during the session. For a visual representation of our progress, detailed screenshots and graphs showcasing the training outcomes are provided below. These visual aids offer a transparent and comprehensive view of our achievements, highlighting the strides we've made in understanding Swahili news classification using LSTM.

CONCLUSION

This step-by-step guide provides a comprehensive overview of the technical implementation, offering both beginner and experienced community members an instructive roadmap for Swahili news classification using LSTM. Each part contributes to the general understanding of the project, from data preprocessing to model inferencing.

In conclusion, the session stood as proof of our community's strength and commitment to sharing knowledge. Guided by the expertise of our members, Edgar Gulay, who led a hands-on task through a Jupyter notebook, everyone had the chance to contribute key ideas and actively engage in the session. As the community looks forward to future sessions, the spirit of collaboration and exploration remains at the forefront.

Have you ever wondered what LLMs are and why they are so popular? You are not alone. Many people have heard of LLMs, but few actually know what they entail, how they benefit, or how to pursue them. In fact, there is a humorous post on LinkedIn that captures this confusion perfectly:

LLMs are like trendy diets, everyone talks about them, no one really knows how to do them, everyone thinks everyone else is doing them, so everyone claims they are doing them.

Unlike trendy diets, LLMs are not a passing trend. They are a prestigious and worthwhile academic degree that can boost your skills and career prospects. In this article, I will give you a brief introduction to LLMs, and explain what they are, why they are popular, how they work and how to actually use them.

INTRODUCTION

Large Language Models (LLMs) are advanced artificial intelligence (AI) systems that can understand and generate human-like language. They can perform various language tasks, such as answering questions, summarising text, translating languages, and even composing poetry. LLMs have revolutionised the field of natural language processing (NLP) and opened up new possibilities for various industries and applications. In this article, we will explore what LLMs are, how they work, what they can do, and what challenges and limitations they face.

A Language Model (LLM) basically comprises two essential files within a designated hypothetical directory. One file holds the parameters, known as the parameter file, while the other is the executable file responsible for running the parameters of the Neural Network constituting the language model.

For illustration purposes in this article, we will focus on a specific LLaMa 2 series model – the llama-2-70b model. This particular model has 70 billion parameters, all thoroughly trained on a substantial portion of text sourced from the internet.

The parameters themselves represent the weights of the Neural Network. In the case of the llama-2-70b model, an open-source model from Meta, each parameter is stored as 2 bytes, resulting in a parameters file size of 140 GB.

OBTAINING THE PARAMETERS (Model Training)

Running an LLM, specifically model inferencing, is a relatively undemanding task. The computational complexity comes into play when accessing the parameters, particularly during the model training phase.

Obtaining the parameters involves a process similar to condensing or compressing the internet. Textual segments from the internet, along with various document types, undergo compression, forming what can be conceptualised as a zip file of the internet. This can visually witnessed in the image below:

However, it's essential to note that this process isn't a conventional compression; instead, it employs a lossy compression method, distinct from the typical lossless compression.

In contemporary model training, the above numbers numbers may seem modest, as they are understated by a factor of 10 or more. This assertion underscores the justification for the substantial financial investments—amounting to tens and hundreds of dollars—in the training of Language Models (LLMs). This training involves extensive clusters and datasets.

Once the parameters are obtained through the completion of the model training phase, executing the model (model inferencing) becomes a relatively computationally economical task.

NEURAL NETWORKS

Essentially, Language Models (LLMs) operate by predicting the next word in a sequence. Mathematically, it can be demonstrated that there exists a close correlation between prediction and compression. This is the reason why the process of training the Neural Network (NN) is often likened to compressing the internet. The NN becomes skilled at accurately predicting the next word by leveraging the insights derived from the compressed dataset.

Although the concept of predicting the next word may sound straightforward in the preceding passages, it is, in reality, a strong objective. This objective forces the Neural Net to acquire a wealth of knowledge about the world within the parameters of the Neural Network.

To illustrate, consider a random Wikipedia search:

Now put yourself in the shoes of the Neural Net attempting to predict the next word, you'd encounter words loaded with information, many of them highlighted in blue. Given the task of predicting the next word, the parameters must grasp a lot of knowledge such as the first and last name, birthplace of Chandler, his friendships, whether he is a fictional character, his residence, nationality, occupation, and more. Consequently, in the pursuit of next-word prediction, all the acquired knowledge is condensed or compressed and stored within the parameters.

HOW DO WE ACTUALLY USE THE NEURAL NETS?

When we execute a Neural Network or a Language model, what we receive is akin to a web page dream or hallucination. The neural network essentially "dreams" the content of internet documents.

The NN generates texts from the distribution it was trained on, essentially mimicking these documents. In essence, it engages in a form of hallucination based on the lossy compression applied during the model training phase.

Let's explore a couple of examples to illustrate this process. Consider the generation of ISBNs: the number produced may not exist in reality, but it is generated based on the Neural Net's understanding that after the word "ISBN" comes a number of a certain length and with specific digits. The NN then fabricates a number that aligns with these criteria.

Another example involves prompting the model to discuss a specific animal, like a koala bear. The Neural Net produces information about the koala bear based on the knowledge embedded in its parameters. This knowledge is acquired through lossy compression during the training phase. However, the model doesn't regurgitate information verbatim from a particular internet source it was trained on.

In the instances mentioned above, we witness the Language model or the Neural Net in its hallucinatory or dream-like state.

HOW THE NEURAL NETWORK WORKS

In this segment of the article, we delve into the mechanics of how the Neural Network or the Language Model accomplishes the task of predicting the next word. This is where things start to get a bit complex.

Here, we zoom in on the diagram of the Neural network, known as the Transformer neural network architecture. A comprehensive understanding involves delving into the mathematical operations and the various stages implicated in the next word prediction task.

However, full comprehension is elusive, and what we do know in detail is limited:

1. There are billions of parameters distributed throughout the neural network.
2. We know how to iteratively adjust and fine-tune these parameters to enhance predictive capabilities.
3. While we can measure the model's performance and probability, understanding how each of the billions of parameters contributes to this performance remains a challenge.

The neural nets construct a knowledge database, but it remains somewhat perplexing, messy, and imperfect. An example illustrating this is the concept of what is known as "reverse course."

For instance, if you ask ChatGPT about the mother of Tom Cruise, it might correctly respond with Mary Lee Pfeiffer. However, in the same chat, if you inquire about Mary Lee Pfeiffer's son, it might answer with Tom Cruise.

Interestingly, if you pose the question in a separate chat, asking specifically about Mary Lee Pfeiffer's son, you might receive a response indicating a lack of clarity.

This demonstrates that the knowledge base is somewhat messy and one-dimensional. It cannot be readily accessed in any direction, requiring a specific approach to access information—a phenomenon known as Prompt Engineering.

CONCLUSION

In summary, Language Models (LLMs) should be viewed as largely inscrutable artefacts. They differ significantly from engineered structures like cars, where each part and its function are well-understood. LLMs, being Neural Networks resulting from a lengthy optimisation process, are not currently fully understood. While there is a field known as interpretability or mechanistic interpretability attempting to decipher the functions of various parts of Neural Networks, LLMs are presently treated as empirical artefacts. We can input data, measure output and behavior, and analyse responses in diverse scenarios, but the intricate workings remain a subject of ongoing exploration.