updating slim examples

Author: DARREN OBERST

examples/SLIM-Agents/document-clustering.py

@@ -0,0 +1,57 @@
+
+"""This example demonstrates the use of LLM function calls to perform document clustering and
+    automated classification of different parts of a document.  """
+
+from llmware.parsers import Parser
+from llmware.agents import LLMfx
+from llmware.setup import Setup
+
+import os
+
+
+def document_clustering_example ():
+
+    samples_fp = Setup().load_sample_files(over_write=True)
+    agreements_fp = os.path.join(samples_fp, "Agreements")
+    agreement_files = os.listdir(agreements_fp)
+
+    if len(agreement_files) == 0:
+        print("something went wrong")
+        return -1
+
+    # parsing the first file (could be random) found in the os.listdir in the Agreements sample folder
+    contract_chunks = Parser().parse_one_pdf(agreements_fp,agreement_files[0])
+
+    #   create a LLMfx object
+    agent = LLMfx()
+
+    #   there are ~65-70 contract_chunks in ~15 page contract - feel free to slice (faster demo), or the whole thing
+    agent.load_work(contract_chunks[0:5])
+
+    agent.load_tool_list(["topics","tags", "ner"])
+
+    while True:
+        agent.exec_multitool_function_call(["topics", "tags","ner"])
+
+        if not agent.increment_work_iteration():
+            break
+
+    agent.show_report()
+
+    agent.activity_summary()
+
+    # uncomment this to see a full view of all of the responses
+    """
+    for i, entries in enumerate(agent.response_list):
+        print("response_list: ", i, entries)
+    """
+
+    return agent.response_list
+
+
+if __name__ == "__main__":
+
+    analysis= document_clustering_example()
+
+
+

examples/SLIM-Agents/ner-retrieval.py

@@ -0,0 +1,47 @@
+
+""" This example illustrates a common two-step retrieval pattern using a SLIM NER model:
+
+        Step 1:  Extract named entity information from a text.  In this case, the name of a musician.
+        Step 2:  Use the extracted name information as the basis for a retrieval.  In this case, we will use the
+                 extracted named entities to do a lookup in Wikipedia. """
+
+from llmware.agents import LLMfx
+from llmware.parsers import WikiParser
+
+
+def ner_lookup_retrieval():
+
+    text = ("The new Miko Marks album is one of the best I have ever heard in a number of years.  "
+            "She is definitely an artist worth exploring further.")
+
+    #   create agent
+    agent = LLMfx()
+    agent.load_work(text)
+    agent.load_tool("ner")
+    named_entities = agent.ner()
+    ner_dict= named_entities["llm_response"]
+
+    #   take named entities found and package into a lookup list
+
+    lookup = []
+    for keys, value in ner_dict.items():
+        if value:
+            lookup.append(value)
+
+    for entries in lookup:
+
+        # run a wiki topic query with each of the named entities found
+
+        wiki_info = WikiParser().add_wiki_topic(entries, target_results=1)
+
+        print("update: wiki_info - ", wiki_info)
+        summary = wiki_info["articles"][0]["summary"]
+
+        print("update: summary - ", summary)
+
+    return 0
+
+
+if __name__ == "__main__":
+
+    ner_lookup_retrieval()

examples/SLIM-Agents/sentiment-analysis.py

@@ -0,0 +1,98 @@
+
+""" Sentiment Analysis example - shows how to use the slim-sentiment-tool.  In this example, we will:
+
+        1.  Review several summary earnings transcripts, looking to evaluate the overall sentiment as
+        'positive', 'negative', or 'neutral'
+
+        2.  Evaluate a single transcript, and apply if...then based on the result and confidence level.
+
+        3.  Run through a list of earnings transcripts with journaling activated to display the multi-step
+        process on the screen.
+"""
+
+from llmware.agents import LLMfx
+
+earnings_transcripts = [
+    "This is one of the best quarters we can remember for the industrial sector with significant growth across the "
+    "board in new order volume, as well as price increases in excess of inflation.  We continue to see very strong "
+    "demand, especially in Asia and Europe. Accordingly, we remain bullish on the tier 1 suppliers and would be "
+    "accumulating more stock on any dips. ",
+
+    "Not the worst results, but overall we view as negative signals on the direction of the economy, and the likely "
+    "short-term trajectory for the telecom sector, and especially larger market leaders, including AT&T, Comcast, and"
+    "Deutsche Telekom.",
+
+    "This quarter was a disaster for Tesla, with falling order volume, increased costs and supply, and negative "
+    "guidance for future growth forecasts in 2024 and beyond.",
+
+    "On balance, this was an average result, with earnings in line with expectations and no big surprises to either "
+    "the positive or the negative."
+    ]
+
+
+def get_one_sentiment_classification(text):
+
+    """This example shows a basic use to get a sentiment classification and use the output programmatically. """
+
+    #   simple basic use to get the sentiment on a single piece of text
+    agent = LLMfx(verbose=True)
+    agent.load_tool("sentiment")
+    sentiment = agent.sentiment(text)
+
+    #   look at the output
+    print("sentiment: ", sentiment)
+    for keys, values in sentiment.items():
+        print(f"{keys}-{values}")
+
+    #   two key attributes of the sentiment output dictionary
+    sentiment_value = sentiment["llm_response"]["sentiment"]
+    confidence_level = sentiment["confidence_score"]
+
+    #   use the sentiment classification as a 'if...then' decision point in a process
+    if "positive" in sentiment_value:
+        print("sentiment is positive .... will take 'positive' analysis path ...", sentiment_value)
+
+    if "positive" in sentiment_value and confidence_level > 0.8:
+        print("sentiment is positive with high confidence ... ", sentiment_value, confidence_level)
+
+    return sentiment
+
+
+def review_batch_earning_transcripts():
+
+    """ This example highlights how to review multiple earnings transcripts and iterate through a batch
+    using the load_work mechanism. """
+
+    agent = LLMfx()
+    agent.load_tool("sentiment")
+
+    #   iterating through a larger list of samples
+    #   note: load_work method is a flexible input mechanism - pass a string, list, dictionary or combination, and
+    #   it will 'package' as iterable units of processing work for the agent
+
+    agent.load_work(earnings_transcripts)
+
+    while True:
+        output = agent.sentiment()
+        # print("update: test - output - ", output)
+        if not agent.increment_work_iteration():
+            break
+
+    response_output = agent.response_list
+
+    agent.clear_work()
+    agent.clear_state()
+
+    return response_output
+
+
+if __name__ == "__main__":
+
+    #   first - quick illustration of getting a sentiment classification
+    #   and using in an "if...then"
+    sentiment = get_one_sentiment_classification(earnings_transcripts[0])
+
+    #   second - iterate thru a batch of transcripts and apply a sentiment classification
+    # response_output = review_batch_earning_transcripts()
+
+

examples/SLIM-Agents/text2sql-end-to-end-2.py

@@ -0,0 +1,111 @@
+
+
+""" This example shows an end-to-end recipe for querying SQL database using only natural language.
+
+    The example shows the following steps:
+
+    1.  Loading "slim-sql-tool" and running initial tests to confirm installation.
+    2.  Generating a SQL table from a sample CSV file included with the slim-sql-tool install.
+    3.  Asking basic natural language questions:
+        A.  Looks up the table schema
+        B.  Packages the table schema with query
+        C.  Runs inference to convert text into SQL
+        D.  Queries the database with the generated SQL
+        E.  Returns result
+    3.  All work performed on an integrated 'llmware-sqlite-experimental.db' that can be deleted safely anytime
+     as part of experimentation lifecycle.
+
+"""
+
+import os
+
+from llmware.agents import SQLTables, LLMfx
+from llmware.models import ModelCatalog
+from llmware.configs import LLMWareConfig
+
+
+def sql_e2e_test_script(table_name="customers1",create_new_table=False):
+
+    """ This is the end-to-end execution script. """
+
+    #   create table if needed to set up
+    if create_new_table:
+
+        # looks to pull sample csv 'customer_table.csv' from slim-sql-tool model package files
+        sql_tool_repo_path = os.path.join(LLMWareConfig().get_model_repo_path(), "slim-sql-tool")
+
+        if not os.path.exists(sql_tool_repo_path):
+            ModelCatalog().load_model("llmware/slim-sql-tool")
+
+        files = os.listdir(sql_tool_repo_path)
+        csv_file = "customer_table.csv"
+
+        if csv_file in files:
+
+            #   to create a testing table from a csv
+            sql_db = SQLTables(experimental=True)
+            sql_db.create_new_table_from_csv(sql_tool_repo_path, csv_file, table_name=table_name)
+            #   end - creating table
+
+            print("update: successfully created new db table")
+        else:
+            print("something has gone wrong - could not find customer_table.csv inside the slim-sql-tool file package")
+
+    #   query starts here
+    agent = LLMfx()
+    agent.load_tool("sql")
+
+    #  Pass direct queries to the DB
+
+    query_list = ["Which customers are vip customers?",
+                  "What is the highest annual spend of any customer?",
+                  "Which customer has account number 1234953",
+                  "Which customer has the lowest annual spend?",
+                  "Is Susan Soinsin a vip customer?"]
+
+    for i, query in enumerate(query_list):
+
+        #   query_db method is doing all of the work
+        #   -- looks up the table schema in the db using the table_name
+        #   -- packages the text-2-sql query prompt
+        #   -- executes sql method to convert the prompt into a sql query
+        #   -- attempts to execute the sql query on the db
+        #   -- returns the db results as 'research' output
+
+        response = agent.query_db(query, table=table_name)
+
+    for x in range(0,len(agent.research_list)):
+        print("research: ", x, agent.research_list[x])
+
+    return 0
+
+def delete_table(table_name):
+
+    """ Start fresh in testing - delete table in experimental local SQLite DB """
+
+    sql_db = SQLTables(experimental=True)
+    sql_db.delete_table(table_name, confirm_delete=True)
+
+    return True
+
+
+def delete_db():
+
+    """ Start fresh in testing - deletes SQLite DB and starts over. """
+
+    sql_db = SQLTables(experimental=True)
+    sql_db.delete_experimental_db(confirm_delete=True)
+
+    return True
+
+
+if __name__ == "__main__":
+
+    ModelCatalog().get_llm_toolkit()
+
+    #   run an end-to-end test
+    sql_e2e_test_script(table_name="customer1",create_new_table=True)
+
+    #   third - delete and start fresh for further testing
+    delete_table("customer1")
+

examples/SLIM-Agents/text2sql-getting-started-1.py

@@ -0,0 +1,53 @@
+
+""" This 'getting started' example shows the basics of how to start using text2sql model:
+
+    1.   Loading "slim-sql-tool" and running initial tests to confirm installation.
+
+    2.   'Hello World' demonstration of how to 'package' a text2sql prompt combining a
+        natural language query with a SQL table schema and run a basic inference to generate SQL output
+
+"""
+
+
+from llmware.agents import LLMfx
+from llmware.models import ModelCatalog
+
+
+def load_slim_sql_tool():
+
+    """ First step is to install the slim-sql-tool locally """
+
+    #   to cache locally the slim-sql-tool with config and test files
+    ModelCatalog().get_llm_toolkit(["sql"])
+
+    #   to run tests to confirm correct installation and see the model in action
+    #   note: the test results will include some minor errors - useful to learn how to sharpen prompts
+    ModelCatalog().tool_test_run("slim-sql-tool")
+
+    return 0
+
+
+def hello_world_text_2_sql():
+
+    """ Illustrates a 'hello world' text-2-sql inference as part of an agent process. """
+
+    sample_table_schema = "CREATE TABLE customer_info (customer_name text, account_number integer, annual_spend integer)"
+
+    query = "What are the names of all customers with annual spend greater than $1000?"
+
+    agent = LLMfx(verbose=True)
+    response = agent.sql(query, sample_table_schema)
+
+    print("update: text-2-sql response - ", response)
+
+    return response
+
+
+if __name__ == "__main__":
+
+    #   first - load and test the tools
+    load_slim_sql_tool()
+
+    #   second - 'hello world' demo of using text2sql model
+    hello_world_text_2_sql()
+