Anthropic has acquired the dev tools startup used by OpenAI, Google, and Cloudflare

Introduction

In this tutorial, you'll learn how to work with Software Development Kits (SDKs) - the libraries that make it easy for developers to interact with APIs. We'll walk through creating a simple Python SDK using the principles that companies like Stainless, which was recently acquired by Anthropic, help developers automate. SDKs are essential tools that save developers hours of work by providing pre-built functions to connect to services like AI platforms, cloud storage, or payment processors.

Prerequisites

• A basic understanding of Python programming
• Python 3.6 or higher installed on your computer
• A code editor (like VS Code or PyCharm)
• Basic knowledge of APIs and how they work

Step-by-step instructions

Step 1: Understanding What an SDK Is

Before we start coding, let's understand what we're building. An SDK (Software Development Kit) is a collection of tools, libraries, and documentation that helps developers create applications for a specific platform or service. Think of it like a toolkit that makes building software easier.

For example, if you wanted to build an app that uses OpenAI's language models, you wouldn't want to write all the HTTP requests and JSON parsing yourself. Instead, you'd use an SDK that already has these functions built-in.

Step 2: Setting Up Your Development Environment

First, let's create a project directory and set up our Python environment:

mkdir my_sdk_project
 cd my_sdk_project
 python3 -m venv sdk_env
 source sdk_env/bin/activate  # On Windows: sdk_env\Scripts\activate

Why we do this: Creating a virtual environment isolates our project dependencies, preventing conflicts with other Python projects on your system.

Step 3: Installing Required Dependencies

Now let's install the packages we'll need:

pip install requests
pip install setuptools
pip install twine

Why we do this:

• requests: Makes HTTP requests easy
• setuptools: Helps us package our SDK
• twine: Used to upload our package to PyPI (Python Package Index)

Step 4: Creating the Basic SDK Structure

Let's create our main SDK file:

mkdir my_sdk
 touch my_sdk/__init__.py
 touch my_sdk/client.py
 touch setup.py

Why we do this: This creates the basic folder structure for our Python package. The __init__.py file makes the directory a Python package, and client.py will contain our main SDK logic.

Step 5: Implementing the Core SDK Logic

Open my_sdk/client.py and add this code:

import requests


class MyAPIClient:
    def __init__(self, api_key, base_url="https://api.example.com"):
        self.api_key = api_key
        self.base_url = base_url
        self.session = requests.Session()
        self.session.headers.update({
            'Authorization': f'Bearer {api_key}',
            'Content-Type': 'application/json'
        })

    def get_user(self, user_id):
        """Get user information by ID"""
        response = self.session.get(f'{self.base_url}/users/{user_id}')
        response.raise_for_status()
        return response.json()

    def create_user(self, user_data):
        """Create a new user"""
        response = self.session.post(f'{self.base_url}/users', json=user_data)
        response.raise_for_status()
        return response.json()

    def delete_user(self, user_id):
        """Delete a user by ID"""
        response = self.session.delete(f'{self.base_url}/users/{user_id}')
        response.raise_for_status()
        return response.json()

Why we do this: This creates a simple client class that handles API communication. The class stores the API key, sets up session headers for authentication, and provides methods for common operations (get, create, delete users).

Step 6: Creating the Package Entry Point

Open my_sdk/__init__.py and add:

from .client import MyAPIClient

__version__ = '0.1.0'
__all__ = ['MyAPIClient']

Why we do this: This file makes our SDK importable and defines what gets exported when someone imports our package.

Step 7: Setting Up the Package Configuration

Create a setup.py file with this content:

from setuptools import setup, find_packages

with open("README.md", "r", encoding="utf-8") as fh:
    long_description = fh.read()

setup(
    name="my-sdk",
    version="0.1.0",
    author="Your Name",
    author_email="[email protected]",
    description="A simple SDK for example API",
    long_description=long_description,
    long_description_content_type="text/markdown",
    url="https://github.com/yourusername/my-sdk",
    packages=find_packages(),
    classifiers=[
        "Programming Language :: Python :: 3",
        "License :: OSI Approved :: MIT License",
        "Operating System :: OS Independent",
    ],
    python_requires='>=3.6',
    install_requires=[
        "requests>=2.20.0",
    ],
)

Why we do this: This file tells Python how to package and distribute our SDK. It includes metadata about the package, dependencies, and how to install it.

Step 8: Testing Your SDK

Let's create a simple test to make sure our SDK works:

import unittest
from my_sdk import MyAPIClient


class TestMyAPIClient(unittest.TestCase):
    def test_client_initialization(self):
        client = MyAPIClient('test_key')
        self.assertEqual(client.api_key, 'test_key')

if __name__ == '__main__':
    unittest.main()

Why we do this: Writing tests ensures our SDK works as expected and helps prevent breaking changes when we make updates.

Step 9: Installing Your SDK Locally

While in your project directory, run:

pip install -e .

Why we do this: The -e flag installs your package in 'editable' mode, which means changes to your source code are immediately reflected without reinstalling.

Step 10: Using Your SDK

Now you can use your SDK in other projects:

from my_sdk import MyAPIClient

# Create client instance
client = MyAPIClient('your_api_key_here')

# Use the SDK methods
try:
    user = client.get_user(123)
    print(user)
except Exception as e:
    print(f"Error: {e}")

Why we do this: This demonstrates how other developers would actually use your SDK in real applications.

Summary

In this tutorial, you've learned how to create a basic SDK that helps developers interact with APIs. You've created a Python package with methods for common operations, set up proper project structure, and learned how to test and install your SDK. This is the foundation of what companies like Stainless help automate - making it easier for developers to create and maintain SDKs for various services.

Remember, real SDKs are much more complex, but this simple example shows the core concepts. As you progress, you'll add features like error handling, rate limiting, authentication, and more sophisticated API interactions.