Follow this short guide to get up and running with the Isaacus API by classifying your first legal document with our flagship Kanon Universal Classifier model.

​
1. Set up your account

Head to the Isaacus Platform to create a new account.

Once signed up, add a payment method.

After adding a payment method, create a new API key.

Make sure to keep your API key safe. You won’t be able to see it again after you create it. But don’t worry, you can always generate a new one.

​
2. Install the Isaacus API client

Now that your account is set up, install the Isaacus API client using pip (or check out our REST API docs if you’re not using Python).

pip install isaacus

​
3. Classify a document

With our API client installed, let’s classify our first legal document.

To start, you need to initialize the client with your API key. You can do this by setting the ISAACUS_API_KEY environment variable or by passing it directly, which is what we’re doing in this example.

from isaacus import Isaacus

client = Isaacus(api_key="PASTE_YOUR_API_KEY_HERE")

Next, let’s grab a legal document to classify. For this example, we’ll use Github’s terms of service.

tos = client.get(path="https://examples.isaacus.com/github-tos.md", cast_to=str)

We’re going to classify the terms of service using our flagship Kanon Universal Classifier, the world’s most accurate universal legal AI classifier.

What is a universal classifier? A universal classifier (also known as a zero-shot classifier) is a system that classifies whether a statement expressed about a document (e.g., “This is a confidentiality clause.”) is supported by that document. Unlike traditional classifiers, universal classifiers don’t require training data to classify a document.

Right now, we’re interested in pulling out confidentiality clauses from the terms of service.

To do that, we’ll use the query This is a confidentiality clause..

classification = client.classifications.universal.create(
    model="kanon-universal-classifier",
    query="This is a confidentiality clause.",
    text=tos,
)

Let’s unpack the results.

chunks = classification.chunks
score = classification.score
usage = classification.usage

Because legal documents can often be quite long, the classifier will automatically break them up into chunks for you. Typically, these chunks will correspond to individual clauses in the document.

Chunks are stored in the classification.chunks attribute and come with their own text, score, start, and end attributes, with start and end representing the start and end indices of the chunk in the original text.

Overall classification scores are currently computed as the maximum score of all the chunks. Scores range from 0.00.0 to 1.01.0, with a score over 0.50.5 indicating a positive classification. You can think of the scores as the classifier’s estimation of the likelihood that the query is supported by the document.

classification.usage contains statistics about the usage of resources in the process of classifying the document. classification.usage.input_tokens will give you the number of tokens inputted into the classifier, which you can cross-reference with our pricing to estimate the cost of classifying the document (excluding applicable taxes).

Now, let’s print out the results.

# Print the overall classification score.
print(
    f'Likelihood of there being a confidentiality clause: {score * 100:.2f}%',
    end='\n\n',
)

# Filter out chunks with a score below 50%.
chunks = filter(lambda c: c.score > 0.5, chunks)

# Sort the chunks from highest to lowest score.
chunks = sorted(chunks, key=lambda c: c.score, reverse=True)

# Print the chunks.
for chunk in chunks:
    chunk_text = chunk.text
    chunk_score = chunk.score
    start, end = chunk.start, chunk.end

    # Print the chunk in the format:
    # ---------- start char = {start} | end char = {end} | score = {chunk_score * 100}% ----------
    # {chunk_text}

    print(
        '-' * 10,
        f'start char = {start:,} | end char = {end:,} | score = {chunk_score:.2%}',
        '-' * 10,
        '\n',
        chunk_text,
        end='\n\n',
    )

The output should look something like this:

Likelihood of there being a confidentiality clause: 79.06%

---------- start char = 19,966 | end char = 22,311 | score = 98.28% ---------- 
 ### 2. Confidentiality of Private Repositories

GitHub considers the contents of private repositories to be confidential to...

And that’s it! You’ve just classified a legal document using the Kanon Universal Classifier.

​
4. Advanced: write your own queries

In the previous example, we used a simple, plain English query to classify confidentiality clauses.

That worked fine for our purposes, but what if you needed to absolutely maximize the accuracy of your classifications?

One way is to construct a test dataset and then repeatedly evaluate differently worded queries on that dataset until you find the best one. This is a time-consuming process, but it can yield excellent results.

The good news is that, for a whole bunch of legal classification problems, we’ve already done that work for you.

Each of our models comes with a set of pre-optimized queries that you can use to classify legal documents with high accuracy and minimal effort.

These queries can be accessed using the Isaacus Query Language or IQL.

IQL is the world’s first legal AI query language — that is, a query language designed specifically for analyzing legal documents with AI systems.

Any statement you can think of, including the one we used earlier, qualifies as an IQL statement. You just need to wrap them in curly brackets like so: {This is a confidentiality clause.}.

To invoke a pre-optimized query template, we can express our query in the format {IS <template name>}. You can find a list of available templates here.

For example, we could’ve invoked the {IS confidentiality clause} template to classify confidentiality clauses in the Github terms of service instead of trying to write our own query from scratch. Let’s do that now.

classification = client.classifications.universal.create(
    model="kanon-universal-classifier",
    query="{IS confidentiality clause}",
    text=tos,
)

This time, our most “confidentiality clause”-like chunks have shuffled around a bit, with the top chunk now being:

---------- start char = 25,715 | end char = 27,954 | score = 79.47% ---------- 
... **Confidentiality Obligations.** You agree that any non-public Beta Preview
information we give you, such as information about a private Beta Preview, will
be considered GitHub’s confidential information (collectively, “Confidential
Information”), ...

That certainly sounds like a confidentiality clause.

Our templates cover more than just confidentiality clauses, however. We’ve got templates for pulling out indemnities, force majeure clauses, termination clauses — even unilateral clauses, clauses that benefit or obligate only a single party, often a key indicator of a contract’s one-sidedness and potential for unfairness.

There are also templates that allow you to plug in your own descriptions of what you’re looking for via the format {IS <template name> "<template argument>"}.

For example, if you wanted to identify clauses that specifically obligate the party referred to as “you” in the document, you could use the {IS clause obligation "<party name>"} template like so: {IS clause obligating "You"}.

classification = client.classifications.universal.create(
    model="kanon-universal-classifier",
    query='{IS clause obligating "You"}',
    text=tos,
)

Now, our top chunk is:

---------- start char = 13,300 | end char = 15,403 | score = 78.25% ---------- 
Your use of the Website and Service must not violate any applicable laws,
including copyright or trademark laws, export control or sanctions laws, or
other laws in your jurisdiction. You are responsible for making sure that your
use of the Service is in compliance with laws and any applicable regulations.

If there isn’t a template available for what you’re looking for, you can always try one of our more general templates like {IS clause called "<clause name>"} (e.g., {IS clause called "confidentiality"}) or {IS clause that "<clause description>"} (e.g., {IS clause that "imposes a duty of confidentiality"}). We don’t yet have templates for non-contractual classifications, however, our models have been trained on an equal mix of contracts and non-contracts, so you can always write your own queries for those or really anything else you can think of.

In addition to allowing you to invoke query templates, IQL also enables you to string statements together using logical operators like AND, OR, and NOT, as well as the > and < comparison operators and the + operator for averaging.

For example, if we wanted to identify confidentiality clauses that apply to you and you alone, we could use this query: {IS confidentiality clause} AND {IS clause obligating "You"} AND {IS unilateral clause}.

classification = client.classifications.universal.create(
    model="kanon-universal-classifier",
    query='{IS confidentiality clause} AND {IS clause obligating "You"} AND {IS unilateral clause}',
    text=tos,
)

That query pulls up the top chunk from before, which is indeed a unilateral confidentiality clause.

Congratulations on becoming an IQL pro!

​
5. Next steps

Beyond the examples we’ve shared here, there’s a lot more that you can do with our API and the Isaacus Query Language.

For a full rundown of the IQL, check out its documentation.

If you’re interested in learning more about our API, check out our API documentation.

And if you want to understand just how affordable our legal APIs are, check out our pricing.

Otherwise, if you have any questions, feel free to reach out to us via our contact form. We’re always happy to help.

HomeModels