modelscopedownload--model=qwen/Qwen2-7B-Instruct-GGUF--local_dir.qwen2-7b-instruct-q5_k_m.gguf

modelscope download --model=modelscope/ollama-linux --local_dir ./ollama-linuxcd ollama-linuxsudo chmod 777 ./ollama-modelscope-install.sh./ollama-modelscope-install.sh

FROM /mnt/workspace/qwen2-7b-instruct-q5_k_m.gguf
# set the temperature to 0.7 [higher is more creative, lower is more coherent]PARAMETER temperature 0.7PARAMETER top_p 0.8PARAMETER repeat_penalty 1.05TEMPLATE """{{ if .Messages }}{{- if or .System .Tools }}<|im_start|>system{{ .System }}{{- if .Tools }}
# Tools
You are provided with function signatures within <tools></tools> XML tags. You may call one or more functions to assist with the user query. Don't make assumptions about what values to plug into functions. Here are the available tools:<tools>{{- range .Tools }}{{ .Function }}{{- end }}</tools>
For each function call, return a JSON object with function name and arguments within <tool_call></tool_call> XML tags as follows:<tool_call>{"name": <function-name>, "arguments": <args-json-object>}</tool_call>{{- end }}<|im_end|>{{- end }}{{- range .Messages }}{{- if eq .Role "user" }}<|im_start|>{{ .Role }}{{ .Content }}<|im_end|>{{- else if eq .Role "assistant" }}<|im_start|>{{ .Role }}{{- if .Content }}{{ .Content }}{{- end }}{{- if .ToolCalls }}<tool_call>{{ range .ToolCalls }}{"name": "{{ .Function.Name }}", "arguments": {{ .Function.Arguments }}}{{ end }}</tool_call>{{- end }}<|im_end|>{{- else if eq .Role "tool" }}<|im_start|>user<tool_response>{{ .Content }}</tool_response><|im_end|>{{- end }}{{- end }}<|im_start|>assistant{{ else }}{{ if .System }}<|im_start|>system{{ .System }}<|im_end|>{{ end }}{{ if .Prompt }}<|im_start|>user{{ .Prompt }}<|im_end|>{{ end }}<|im_start|>assistant{{ end }}"""

ollama create myqwen2 --file ./ModelFile

!pip install scipy --quiet!pip install tenacity --quiet!pip install tiktoken --quiet!pip install termcolor --quiet!pip install openai --quiet

import jsonimport openaifrom tenacity import retry, wait_random_exponential, stop_after_attemptfrom termcolor import colored  
MODEL = "myqwen2"client = openai.OpenAI(    base_url="http://127.0.0.1:11434/v1",    api_key = "None")

@retry(wait=wait_random_exponential(multiplier=1, max=40), stop=stop_after_attempt(3))def chat_completion_request(messages, tools=None, tool_choice=None, model=MODEL):    try:        response = client.chat.completions.create(            model=model,            messages=messages,            tools=tools,            tool_choice=tool_choice,        )        return response    except Exception as e:        print("Unable to generate ChatCompletion response")        print(f"Exception: {e}")        return e

def pretty_print_conversation(messages):    role_to_color = {        "system": "red",        "user": "green",        "assistant": "blue",        "function": "magenta",    }
    for message in messages:        if message["role"] == "system":            print(colored(f"system: {message['content']}\n", role_to_color[message["role"]]))        elif message["role"] == "user":            print(colored(f"user: {message['content']}\n", role_to_color[message["role"]]))        elif message["role"] == "assistant" and message.get("function_call"):            print(colored(f"assistant: {message['function_call']}\n", role_to_color[message["role"]]))        elif message["role"] == "assistant" and not message.get("function_call"):            print(colored(f"assistant: {message['content']}\n", role_to_color[message["role"]]))        elif message["role"] == "function":            print(colored(f"function ({message['name']}): {message['content']}\n", role_to_color[message["role"]]))

tools = [    {        "type": "function",        "function": {            "name": "get_current_weather",            "description": "Get the current weather",            "parameters": {                "type": "object",                "properties": {                    "location": {                        "type": "string",                        "description": "The city and state, e.g. San Francisco, CA",                    },                    "format": {                        "type": "string",                        "enum": ["celsius", "fahrenheit"],                        "description": "The temperature unit to use. Infer this from the users location.",                    },                },                "required": ["location", "format"],            },        }    },    {        "type": "function",        "function": {            "name": "get_n_day_weather_forecast",            "description": "Get an N-day weather forecast",            "parameters": {                "type": "object",                "properties": {                    "location": {                        "type": "string",                        "description": "The city and state, e.g. San Francisco, CA",                    },                    "format": {                        "type": "string",                        "enum": ["celsius", "fahrenheit"],                        "description": "The temperature unit to use. Infer this from the users location.",                    },                    "num_days": {                        "type": "integer",                        "description": "The number of days to forecast",                    }                },                "required": ["location", "format", "num_days"]            },        }    },]

messages = []messages.append({"role": "system", "content": "Don't make assumptions about what values to plug into functions. Ask for clarification if a user request is ambiguous."})messages.append({"role": "user", "content": "hi ，can you tell me what's the weather like today"})chat_response = chat_completion_request(    messages, tools=tools)assistant_message = chat_response.choices[0].messagemessages.append(assistant_message)assistant_message

messages.append({"role": "user", "content": "I'm in Glasgow, Scotland."})chat_response = chat_completion_request(    messages, tools=tools)assistant_message = chat_response.choices[0].messagemessages.append(assistant_message)assistant_message

messages = []messages.append({"role": "system", "content": "Don't make assumptions about what values to plug into functions. Ask for clarification if a user request is ambiguous."})messages.append({"role": "user", "content": "can you tell me, what is the weather going to be like in Glasgow, Scotland in next x days"})chat_response = chat_completion_request(    messages, tools=tools)assistant_message = chat_response.choices[0].messagemessages.append(assistant_message)assistant_message

messages.append({"role": "user", "content": "5 days"})chat_response = chat_completion_request(    messages, tools=tools)chat_response.choices[0]

messages = []messages.append({"role": "system", "content": "Don't make assumptions about what values to plug into functions. Ask for clarification if a user request is ambiguous."})messages.append({"role": "user", "content": "what is the weather going to be like in San Francisco and Glasgow over the next 4 days"})chat_response = chat_completion_request(    messages, tools=tools, model=MODEL)
assistant_message = chat_response.choices[0].message.tool_callsassistant_message

import sqlite3
conn = sqlite3.connect("data/Chinook.db")print("Opened database successfully")

def get_table_names(conn):    """Return a list of table names."""    table_names = []    tables = conn.execute("SELECT name FROM sqlite_master WHERE type='table';")    for table in tables.fetchall():        table_names.append(table[0])    return table_names

def get_column_names(conn, table_name):    """Return a list of column names."""    column_names = []    columns = conn.execute(f"PRAGMA table_info('{table_name}');").fetchall()    for col in columns:        column_names.append(col[1])    return column_names

def get_database_info(conn):    """Return a list of dicts containing the table name and columns for each table in the database."""    table_dicts = []    for table_name in get_table_names(conn):        columns_names = get_column_names(conn, table_name)        table_dicts.append({"table_name": table_name, "column_names": columns_names})    return table_dicts

database_schema_dict = get_database_info(conn)database_schema_string = "\n".join(    [        f"Table: {table['table_name']}\nColumns: {', '.join(table['column_names'])}"        for table in database_schema_dict    ])

tools = [    {        "type": "function",        "function": {            "name": "ask_database",            "description": "Use this function to answer user questions about music. Input should be a fully formed SQL query.",            "parameters": {                "type": "object",                "properties": {                    "query": {                        "type": "string",                        "description": f"""                                SQL query extracting info to answer the user's question.                                SQL should be written using this database schema:                                {database_schema_string}                                The query should be returned in plain text, not in JSON.                                """,                    }                },                "required": ["query"],            },        }    }]

def ask_database(conn, query):    """Function to query SQLite database with a provided SQL query."""    try:        results = str(conn.execute(query).fetchall())    except Exception as e:        results = f"query failed with error: {e}"    return results

messages = [{    "role":"user",     "content": "What is the name of the album with the most tracks?"}]
response = client.chat.completions.create(    model='myqwen2',     messages=messages,     tools= tools,     tool_choice="auto")
# Append the message to messages listresponse_message = response.choices[0].message messages.append(response_message)
print(response_message)

tool_calls = response_message.tool_callsif tool_calls:        tool_call_id = tool_calls[0].id    tool_function_name = tool_calls[0].function.name    tool_query_string = json.loads(tool_calls[0].function.arguments)['query']
        if tool_function_name == 'ask_database':        results = ask_database(conn, tool_query_string)
        messages.append({            "role":"tool",             "tool_call_id":tool_call_id,             "name": tool_function_name,             "content":results        })
                        model_response_with_function_call = client.chat.completions.create(            model="myqwen2",            messages=messages,        )          print(model_response_with_function_call.choices[0].message.content)    else:         print(f"Error: function {tool_function_name} does not exist")else:         print(response_message.content)