modelscope download --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

ollama serve

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

ollama run myqwen2

!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 responseexcept 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)

# Step 2: determine if the response from the model includes a tool call. tool_calls = response_message.tool_callsif tool_calls:# If true the model will return the name of the tool / function to call and the argument(s)tool_call_id = tool_calls[0].idtool_function_name = tool_calls[0].function.nametool_query_string = json.loads(tool_calls[0].function.arguments)['query']
# Step 3: Call the function and retrieve results. Append the results to the messages list.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})
# Step 4: Invoke the chat completions API with the function response appended to the messages list# Note that messages with role 'tool' must be a response to a preceding message with 'tool_calls'model_response_with_function_call = client.chat.completions.create(model="myqwen2",messages=messages,)# get a new response from the model where it can see the function responseprint(model_response_with_function_call.choices[0].message.content)else: print(f"Error: function {tool_function_name} does not exist")else: # Model did not identify a function to call, result can be returned to the user print(response_message.content)