DEV Community: satyamsoni2211

A Developer's Guide to Mastering AI with GitHub Models: Your Free Sandbox for Innovation

satyamsoni2211 — Tue, 10 Jun 2025 12:37:12 +0000

A Developer's Guide to Mastering AI with GitHub Models: Your Free Sandbox for Innovation

In the ever-accelerating world of artificial intelligence, getting hands-on experience with different models is crucial for any developer looking to stay ahead of the curve. The barrier to entry, however, has often been the cost and complexity of setting up the necessary infrastructure. Enter GitHub Models, a powerful feature integrated directly into the GitHub platform that is democratizing access to AI, allowing you to experiment, learn, and build without the need for a paid plan.

This comprehensive guide will walk you through everything you need to know to start leveraging GitHub Models for your personal projects, learning, and prototyping.

What Exactly Are GitHub Models?

GitHub Models provides a suite of tools that enable you to work with various large language models (LLMs) and other AI models directly within your GitHub repository. It acts as a centralized hub for:

Prototyping: Quickly test ideas and experiment with different AI models.
Optimization: Fine-tune your prompts and analyze model performance to get the best results.
Evaluation: Compare the outputs of different models to find the most suitable one for your specific use case.

The most compelling feature for learners and individual developers is its generous free tier, which allows you to explore the capabilities of powerful AI models without incurring any costs.

Use Case Spotlight: Learning and Testing Without Financial Commitment

The primary advantage of GitHub Models for knowledge sharing is its role as a no-cost educational sandbox. Here’s how you can leverage it:

Understand Prompt Engineering: Experiment with different ways to phrase your requests (prompts) to see how it impacts the model's output. This is a fundamental skill in AI development.
Compare Model Capabilities: Pit different models against each other for the same task. You might find that one model excels at creative writing while another is better suited for code generation.
Develop and Test AI-Powered Features: Are you curious about adding a summarization feature to your blog or a chatbot to your personal website? You can build and test the logic using GitHub Models without any financial outlay. Once you have a working prototype, you can then decide if you want to move to a paid, production-level service.

A Step-by-Step Guide to Setting Up and Using GitHub Models

Getting started with GitHub Models is a straightforward process. Follow these steps to enable and begin experimenting.

Step 1: Enable GitHub Models in Your Repository

Before you can start, you need to activate the feature for a specific repository.

Navigate to the main page of the repository where you want to use GitHub Models.
Under your repository name, click on Settings.
In the left sidebar, scroll down to the "Features" section and click on Models.
If the feature is not already enabled, click on Enable Models.

Step 2: Exploring the Model Playground

The Playground is your interactive environment for initial experimentation.

Once enabled, a new Models tab will appear in your repository's main navigation bar. Click on it.
You will be taken to the Model Playground. Here’s what you can do:
- Select a Model: On the left, you'll see a dropdown list of available AI models. Choose one to start.
- Craft Your Prompt: In the main text area, write the prompt you want the model to respond to. Be as descriptive as possible.
- Generate and Analyze: Click the "Generate" button to get the model's response. You can then tweak your prompt and try again to see how the output changes.
- Compare Models: The real power of the playground lies in its comparison feature. You can add multiple models to a session and send the same prompt to all of them simultaneously, allowing for a side-by-side comparison of their responses.

Step 3: Integrating Models into Your Code

After experimenting in the Playground, the next step is to bring the power of these models into your application code. GitHub makes this incredibly simple.

Get the Code Snippet: In the Playground, after you've generated a response, you'll often find an option to view the corresponding code. This will provide you with a ready-to-use snippet, typically in Python or JavaScript.
Set Up Your Environment: Ensure you have the necessary libraries installed. For Python, you'll likely need the openai library, which is often used to interact with these model endpoints.
```
pip install openai
```

Using the API in Your Python Script: The provided code snippet will show you how to make an API call. Here is a conceptual example of what it might look like:

import os
from openai import OpenAI

# GitHub automatically sets the GITHUB_TOKEN for you in Actions,
# or you can use a personal access token for local development.
client = OpenAI(
    base_url="https://api.github.com/models",
    api_key=os.environ.get("GITHUB_TOKEN")
)

chat_completion = client.chat.completions.create(
    messages=[
        {
            "role": "system",
            "content": "You are a helpful assistant."
        },
        {
            "role": "user",
            "content": "Tell me a fun fact about the Roman Empire."
        }
    ],
    model="gpt-4" # Or any other available model
)

print(chat_completion.choices[0].message.content)

Important Note: When running code locally, you will need to create a GitHub Personal Access Token (PAT) with the appropriate permissions and set it as an environment variable. When running your code within a GitHub Actions workflow, the GITHUB_TOKEN is automatically available.

Start Your AI Learning Journey Today

GitHub Models has effectively removed one of the biggest hurdles for developers wanting to delve into AI: cost. By providing a free, integrated, and user-friendly platform for experimentation, GitHub is empowering a new wave of developers to build the next generation of intelligent applications.

So, what are you waiting for? Pick a repository, enable Models, and start turning your innovative AI ideas into reality. Happy coding!

Introducing EventSail: A Python Library for Event-driven Programming

satyamsoni2211 — Fri, 12 Apr 2024 05:31:38 +0000

Are you ready to sail through the world of event-driven programming with ease? Look no further! We're excited to introduce EventSail, a powerful Python library designed to simplify event handling and streamline your development process.

What is EventSail?

EventSail is a lightweight yet robust Python library that empowers developers to effortlessly manage events and callbacks within their applications. Whether you're building a web application, a game, or a complex system, EventSail provides the tools you need to implement efficient event-driven architecture.

Key Features:

Simple API: With a straightforward and intuitive API, EventSail makes it easy to define, trigger, and handle events in your Python projects.
Flexible Event Handling: Customize event handling with ease using EventSail's flexible callback system. Define callbacks for specific events and take control of your application's flow.
Asynchronous Support: Seamlessly integrate EventSail with asynchronous programming paradigms, ensuring smooth performance in asynchronous applications.
Lightweight and Performant: EventSail is designed to be lightweight and performant, minimizing overhead while maximizing efficiency in event processing.
Extensive Documentation: Comprehensive documentation and examples make it simple for developers of all levels to get started with EventSail quickly.

Getting Started:

Ready to set sail with EventSail? Getting started is as easy as 1-2-3:

Installation: Install EventSail via pip:

pip install eventsail

Example Usage: Dive into our comprehensive documentation and explore example use cases to understand how EventSail can elevate your projects.
Contribution: Join our growing community on GitHub! Contribute to the project, report issues, or suggest new features to help us make EventSail even better.

Get Involved!

Join us on this exciting journey as we navigate the seas of event-driven programming together. Whether you're a seasoned developer or just starting out, EventSail is here to simplify your development process and unlock new possibilities.

Ready to embark on your next coding adventure? Set sail with EventSail today!

GitHub Repository: EventSail on GitHub
PyPi Repository: EventSail on PyPi

Extending Python Logger for mailing Exceptions

satyamsoni2211 — Fri, 22 Jul 2022 07:25:11 +0000

Logging is most crucial part of any application or process you create, as it helps you debug or keep track of whats going on. Logging is a very vast topic in itself but super useful when you want to perform some side effects or redirect your output to some other services or perform some side computations etc.

Highly configurable by design, we can add extend functionalities of existing loggers, using custom Handlers.

We will try to extend functionality of existing logger to e-mail exceptions occurred during code execution. Let us create a python Logger using built-in library logging.

import logging
logger: logging.Logger = logging.getLogger()

Above code will return a root logger instance, since we are not mentioning any name explicitly. If you want a named logger instance, you can pass name to getLogger function.

Let us now create a custom Handler to handle records and perform some side effect. We can inherit from logging.Handler abstract base class to create our custom Handler.

logging.Handler base class provides multiple hooks that you can override. We will override emit hook for our requirement.

import logging
class MailHandler(logging.Handler):

    def emit(self, record: logging.LogRecord) -> None:
        if record.exc_info:
            exception = "".join(traceback.format_exception(*record.exc_info))
        else:
            exception = "".join(traceback.format_exception(*sys.exc_info()))
        self._send_mail(exception)

We have added set of statements to intercept exception from the record and create formatted stack trace.

emit hook will receive logging.LogRecord which will contain all the details regarding the record like message, timestamp, line no, exception info etc. We have also added a instance method _send_mail to send formatted stack trace to the user.

Let us now complete _send_mail function. We will use AWS SES for sending e-mail. You may also use smtp as an alternative.

import boto3

class MailHandler(logging.Handler):

    def _send_mail(self, message):
        self.client = boto3.client('ses')
        ses_arn = os.getenv('SES_ARN')
        source = os.getenv('SES_SOURCE')
        html = f"""
        <p>Exception occurred while execution. Please check. </p>
        <pre>{message}</pre>
        """
        self.client.send_email(
            Source=source,
            Destination={
                'ToAddresses': [
                    'foobar@gmail.com',
                ],
            },
            Message={
                'Subject': {
                    'Data': 'Exception occurred while executing Lambda. Please check.',
                },
                'Body': {
                    'Html': {
                        'Data': html
                    }
                }
            },
            SourceArn=ses_arn
        )

We are using boto3 library for connecting to SES and send e-mail.

I am reading ses_arn and source from environment variables. These will be required to send e-mail to the destination address using your configured SES record.

We are done with creating our custom handler. Let us register this with our logger instance.

import logging
logger: logging.Logger = logging.getLogger()
handler = MailHandler()
handler.setLevel(logging.ERROR)
logger.logger_.addHandler(handler)

We have registered our custom handler with our logger instance. It will be only activated on error record type as we have set level to logging.ERROR. You may now test your custom handler as below.

logger.error(Exception("Fake Exception"))

You should receive an email, with exception and stack trace.

Below is the complete code for custom handler.

import boto3
import logging

class MailHandler(logging.Handler):
    def emit(self, record: logging.LogRecord) -> None:
        if record.exc_info:
            exception = "".join(traceback.format_exception(*record.exc_info))
        else:
            exception = "".join(traceback.format_exception(*sys.exc_info()))
        self._send_mail(exception)

    def _send_mail(self, message):
        self.client = boto3.client('ses')
        ses_arn = os.getenv('SES_ARN')
        source = os.getenv('SES_SOURCE')
        html = f"""
        <p>Exception occurred while execution. Please check. </p>
        <pre>{message}</pre>
        """
        self.client.send_email(
            Source=source,
            Destination={
                'ToAddresses': [
                    'foobar@gmail.com',
                ],
            },
            Message={
                'Subject': {
                    'Data': 'Exception occurred while executing Lambda. Please check.',
                },
                'Body': {
                    'Html': {
                        'Data': html
                    }
                }
            },
            SourceArn=ses_arn
        )

logger: logging.Logger = logging.getLogger()
handler = MailHandler()
handler.setLevel(logging.ERROR)
logger.logger_.addHandler(handler)

#raising exception
try:
    raise Exception("Fake Exception")
except Exception as e:
    logger.error(e, exc_info=True)

You can now customize logging handlers has per your requirements.

Happy Logging 😊.

Lazy reflecting Tables to SQLAlchemy ORM

satyamsoni2211 — Mon, 18 Jul 2022 11:58:02 +0000

SQLAlchemy has been in market since a long time now and is one of the best ORM's available so far. When working on backend Frameworks such as Flask or FastAPI, we usually come across this ORM.

There are two approaches, we can use SQLAlchemy:

Creating Schema, Tables manually using declarative_base objects and migrating them.
Reflecting existing objects in the database using metadata.

The issue with later approach is that when there are a lot of tables to work on, initial reflect to all the tables would take a lot of time and increase your application boot time. I came up with an approach to tackle such situations wherein you need to reflect existing tables without degrading application performance.

Idea is to reflect tables and views lazily on requirements rather than loading everything at once. We do not require all the tables at once, do we ?

Since, API's would only be querying or performing CRUD operations on a subset of tables, we have room to skip loading other tables, but also keep already reflected tables persistent.

I have created a lazy wrapper for this purpose which reflects tables on requirements only once and persist them so that you can use same objects going forward.

class LazyDBProp(object):
    """This descriptor returns sqlalchemy
    Table class which can be used to query
    table from the schema
    """

    def __init__(self) -> None:
        self._table = None
        self._name = None

    def __set_name__(self, _, name):
        self._name = name

    def __set__(self, instance, value):
        if isinstance(value, (CustomTable, Table)):
            self._table = value

    def __get__(self, instance, _):
        if self._table is None:
            self._table = CustomTable(
                self._name, instance.metadata, autoload=True)
        return self._table

This class uses descriptors under the hood to persist table or view objects. I have also created a wrapper to generate dynamic class to hold these descriptor based table objects.

def get_lazy_class(engine: Engine) -> object:
    """
    Function to create Lazy class for pulling table object
    using SQLalchemy metadata
    """

    def __init__(self, engine: Engine):
        self.metadata = MetaData(engine)
        self.engine = engine

    def __getattr__(self, attr):
        if attr not in self.__dict__:
            obj = self.__patch(attr)
        return obj.__get__(self, type(self))

    def __patch(self, attribute):
        obj = LazyDBProp()
        obj.__set_name__(self, attribute)
        setattr(type(self), attribute, obj)
        return obj

    # naming classes uniquely for different schema's
    # to avoid cross referencing
    LazyClass = type(f"LazyClass_{engine.url.database}", (), {})
    LazyClass.__init__ = __init__
    LazyClass.__getattr__ = __getattr__
    LazyClass.__patch = __patch
    return LazyClass(engine)

Above class can be simply used as below:

from lazy_alchemy import get_lazy_class
from sqlalchemy import create_engine

db_engine = create_engine(DB_CONNECT_STRING)
lazy_db = get_lazy_class(db_engine)

db_model = lazy_db.my_db_table_foo
query = session.query(db_model).filter(db_model.foo == "bar").all()

Once reflected, these objects can be referenced repeatedly. Reflecting only required object enhances application performance with minimal overhead.

This had me cut down application boot time from more than a minute to couple of seconds :).

If you want to implement above in your project, you can simply use my pypi package Lazy Alchemy.

I would be happy to hear you views and alternatives to this approach.

Thank you for reading this, I hope you found some helpful tips.