Update slop_with_models.py
This commit is contained in:
parent
b2a7f9838d
commit
b7c7f2b3ea
1 changed files with 94 additions and 57 deletions
|
|
@ -1,4 +1,3 @@
|
|||
# slop_with_models.py
|
||||
from flask import Flask, request, jsonify
|
||||
from datetime import datetime
|
||||
import os
|
||||
|
|
@ -8,15 +7,19 @@ from flask_swagger_ui import get_swaggerui_blueprint
|
|||
|
||||
# Configure logging
|
||||
logging.basicConfig(
|
||||
level=logging.DEBUG, format="%(asctime)s - %(levelname)s - %(message)s"
|
||||
level=logging.DEBUG,
|
||||
handlers=[
|
||||
logging.FileHandler("slop_with_models.log"), # Log to a file
|
||||
logging.StreamHandler(), # Also log to console
|
||||
]
|
||||
)
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
app = Flask(__name__)
|
||||
|
||||
# Swagger UI setup
|
||||
SWAGGER_URL = "/openapi" # URL for Swagger UI
|
||||
API_URL = "/static/openapi.yaml" # Path to the OpenAPI spec file
|
||||
SWAGGER_URL = "/openapi"
|
||||
API_URL = "/static/openapi.yaml"
|
||||
swaggerui_blueprint = get_swaggerui_blueprint(
|
||||
SWAGGER_URL, API_URL, config={"app_name": "SLOP API"}
|
||||
)
|
||||
|
|
@ -31,50 +34,49 @@ ENDPOINTS = []
|
|||
for i in range(1000):
|
||||
endpoint = os.getenv(f"MODEL_ENDPOINT_{i}")
|
||||
if endpoint:
|
||||
api_key = os.getenv(f"MODEL_API_KEY_{i}", "not-needed")
|
||||
logger.info(f"Loaded endpoint {i}: {endpoint} with API key: {api_key[:4]}...")
|
||||
ENDPOINTS.append(
|
||||
{
|
||||
"name": f"endpoint_{i}",
|
||||
"base_url": endpoint,
|
||||
"api_key": os.getenv(f"MODEL_API_KEY_{i}", "not-needed"),
|
||||
"api_key": api_key,
|
||||
}
|
||||
)
|
||||
|
||||
else:
|
||||
logger.debug(f"No endpoint found for MODEL_ENDPOINT_{i}")
|
||||
|
||||
def initialize_model_map():
|
||||
logger.info("Starting model map initialization")
|
||||
MODEL_CLIENT_MAP.clear()
|
||||
logger.info("Initializing model map...")
|
||||
if not ENDPOINTS:
|
||||
logger.warning("No endpoints configured.")
|
||||
logger.warning("No endpoints configured to initialize models")
|
||||
return
|
||||
for ep in ENDPOINTS:
|
||||
base_url = ep["base_url"]
|
||||
api_key = ep["api_key"]
|
||||
endpoint_name = ep["name"]
|
||||
logger.info(f"Querying endpoint: {endpoint_name} ({base_url})")
|
||||
logger.info(f"Initializing client for {endpoint_name} at {base_url}")
|
||||
client = OpenAI(base_url=base_url, api_key=api_key)
|
||||
try:
|
||||
logger.debug(f"Attempting to list models from {endpoint_name}")
|
||||
response = client.models.list()
|
||||
model_list = response.data
|
||||
logger.debug(
|
||||
f"{endpoint_name} returned models: {[m.id for m in model_list]}"
|
||||
)
|
||||
logger.debug(f"Models retrieved from {endpoint_name}: {[m.id for m in model_list]}")
|
||||
except Exception as e:
|
||||
logger.error(
|
||||
f"Skipping, Failed to list models for {endpoint_name}: {str(e)}"
|
||||
)
|
||||
logger.error(f"Failed to list models for {endpoint_name}: {str(e)}", exc_info=True)
|
||||
continue
|
||||
for m in model_list:
|
||||
model_id = m.id
|
||||
if model_id:
|
||||
if model_id in MODEL_CLIENT_MAP:
|
||||
logger.warning(f"Duplicate model ID '{model_id}' found.")
|
||||
logger.warning(f"Duplicate model ID '{model_id}' found at {endpoint_name}")
|
||||
else:
|
||||
MODEL_CLIENT_MAP[model_id] = client
|
||||
logger.info(f"Added model '{model_id}'")
|
||||
logger.info(f"Registered model '{model_id}' from {endpoint_name}")
|
||||
else:
|
||||
logger.warning(f"Encountered model with no ID from {endpoint_name}")
|
||||
logger.info(f"Loaded models: {list(MODEL_CLIENT_MAP.keys())}")
|
||||
|
||||
logger.warning(f"Model with no ID encountered from {endpoint_name}")
|
||||
logger.info(f"Model map initialized with models: {list(MODEL_CLIENT_MAP.keys())}")
|
||||
|
||||
# SLOP components
|
||||
tools = {
|
||||
|
|
@ -91,20 +93,23 @@ tools = {
|
|||
}
|
||||
resources = {"hello": {"id": "hello", "content": "Hello, SLOP!"}}
|
||||
|
||||
|
||||
# Endpoints
|
||||
@app.route("/chat", methods=["POST"])
|
||||
def chat():
|
||||
logger.info("Received /chat request")
|
||||
data = request.json
|
||||
logger.debug(f"Request data: {data}")
|
||||
message = data["messages"][0]["content"] if data.get("messages") else "nothing"
|
||||
model_id = data.get("model") or (
|
||||
list(MODEL_CLIENT_MAP.keys())[0] if MODEL_CLIENT_MAP else None
|
||||
)
|
||||
logger.info(f"Selected model: {model_id}, message: {message}")
|
||||
if not model_id or model_id not in MODEL_CLIENT_MAP:
|
||||
logger.error(f"Invalid or missing model_id: {model_id}")
|
||||
logger.error(f"Invalid or missing model_id: {model_id}, available models: {list(MODEL_CLIENT_MAP.keys())}")
|
||||
return jsonify({"error": "Model not found"}), 404
|
||||
client = MODEL_CLIENT_MAP[model_id]
|
||||
try:
|
||||
logger.debug(f"Sending chat request to model {model_id}")
|
||||
response = client.chat.completions.create(
|
||||
model=model_id,
|
||||
messages=[
|
||||
|
|
@ -113,110 +118,142 @@ def chat():
|
|||
]
|
||||
or [{"role": "user", "content": message}],
|
||||
)
|
||||
logger.debug(
|
||||
f"Chat response for model {model_id}: {response.choices[0].message.content}"
|
||||
)
|
||||
response_content = response.choices[0].message.content
|
||||
logger.debug(f"Chat response from {model_id}: {response_content}")
|
||||
return (
|
||||
jsonify(
|
||||
{
|
||||
"choices": [
|
||||
{"message": {"content": response.choices[0].message.content}}
|
||||
{"message": {"content": response_content}}
|
||||
]
|
||||
}
|
||||
),
|
||||
200,
|
||||
)
|
||||
except Exception as e:
|
||||
logger.error(f"Chat error with model {model_id}: {str(e)}")
|
||||
logger.error(f"Chat error with model {model_id}: {str(e)}", exc_info=True)
|
||||
return jsonify({"error": str(e)}), 500
|
||||
|
||||
|
||||
@app.route("/models", methods=["GET"])
|
||||
def list_models():
|
||||
logger.info("Received /models request")
|
||||
models = list(MODEL_CLIENT_MAP.keys())
|
||||
logger.debug(f"Returning models: {models}")
|
||||
return jsonify({"models": models}), 200
|
||||
|
||||
|
||||
@app.route("/tools", methods=["GET"])
|
||||
def list_tools():
|
||||
return (
|
||||
jsonify(
|
||||
{
|
||||
"tools": [
|
||||
{"id": k, "description": v["description"]} for k, v in tools.items()
|
||||
]
|
||||
}
|
||||
),
|
||||
200,
|
||||
)
|
||||
|
||||
logger.info("Received /tools request")
|
||||
tool_list = [{"id": k, "description": v["description"]} for k, v in tools.items()]
|
||||
logger.debug(f"Returning tools: {tool_list}")
|
||||
return jsonify({"tools": tool_list}), 200
|
||||
|
||||
@app.route("/tools/<tool_id>", methods=["POST"])
|
||||
def use_tool(tool_id):
|
||||
logger.info(f"Received /tools/{tool_id} request")
|
||||
if tool_id not in tools:
|
||||
logger.error(f"Tool not found: {tool_id}")
|
||||
return jsonify({"error": "Tool not found"}), 404
|
||||
data = request.json or {}
|
||||
logger.debug(f"Tool {tool_id} input data: {data}")
|
||||
if tool_id == "calculator" and "expression" not in data:
|
||||
logger.warning("Missing 'expression' for calculator tool")
|
||||
return jsonify({"error": "Missing 'expression'"}), 400
|
||||
if tool_id == "greet" and "name" not in data:
|
||||
logger.warning("Missing 'name' for greet tool")
|
||||
return jsonify({"error": "Missing 'name'"}), 400
|
||||
try:
|
||||
result = tools[tool_id]["execute"](data)
|
||||
logger.debug(f"Tool {tool_id} result: {result}")
|
||||
return jsonify(result), 200
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error executing tool {tool_id}: {str(e)}", exc_info=True)
|
||||
return jsonify({"error": str(e)}), 500
|
||||
|
||||
@app.route("/memory", methods=["POST"])
|
||||
def store_memory():
|
||||
logger.info("Received /memory POST request")
|
||||
data = request.json
|
||||
memory[data["key"]] = data["value"]
|
||||
logger.debug(f"Store memory data: {data}")
|
||||
if not data or "key" not in data or "value" not in data:
|
||||
logger.warning(f"Invalid memory store request: {data}")
|
||||
return jsonify({"error": "Missing 'key' or 'value'"}), 400
|
||||
key, value = data["key"], data["value"]
|
||||
memory[key] = value
|
||||
logger.info(f"Stored in memory: {key} = {value}")
|
||||
logger.debug(f"Current memory state: {memory}")
|
||||
return jsonify({"status": "stored"}), 200
|
||||
|
||||
|
||||
@app.route("/memory/<key>", methods=["GET"])
|
||||
def get_memory(key):
|
||||
return jsonify({"value": memory.get(key)}), 200
|
||||
|
||||
logger.info(f"Received /memory/{key} GET request")
|
||||
value = memory.get(key)
|
||||
logger.debug(f"Retrieved memory for {key}: {value}")
|
||||
if value is None:
|
||||
logger.warning(f"Key not found in memory: {key}")
|
||||
return jsonify({"value": value}), 200
|
||||
|
||||
@app.route("/memory", methods=["GET"])
|
||||
def list_memory():
|
||||
return jsonify({"keys": list(memory.keys())}), 200
|
||||
|
||||
logger.info("Received /memory GET request")
|
||||
keys = list(memory.keys())
|
||||
logger.debug(f"Memory keys: {keys}")
|
||||
logger.debug(f"Full memory state: {memory}")
|
||||
return jsonify({"keys": keys}), 200
|
||||
|
||||
@app.route("/memory/<key>", methods=["DELETE"])
|
||||
def delete_memory(key):
|
||||
logger.info(f"Received /memory/{key} DELETE request")
|
||||
if key not in memory:
|
||||
logger.warning(f"Key not found for deletion: {key}")
|
||||
return jsonify({"error": "Key not found"}), 404
|
||||
old_value = memory[key]
|
||||
del memory[key]
|
||||
logger.info(f"Deleted from memory: {key} (was {old_value})")
|
||||
logger.debug(f"Updated memory state: {memory}")
|
||||
return jsonify({"status": "deleted"}), 200
|
||||
|
||||
|
||||
@app.route("/resources", methods=["GET"])
|
||||
def list_resources():
|
||||
return jsonify({"resources": list(resources.values())}), 200
|
||||
|
||||
logger.info("Received /resources request")
|
||||
resource_list = list(resources.values())
|
||||
logger.debug(f"Returning resources: {resource_list}")
|
||||
return jsonify({"resources": resource_list}), 200
|
||||
|
||||
@app.route("/resources/<resource_id>", methods=["GET"])
|
||||
def get_resource(resource_id):
|
||||
logger.info(f"Received /resources/{resource_id} request")
|
||||
if resource_id not in resources:
|
||||
logger.error(f"Resource not found: {resource_id}")
|
||||
return jsonify({"error": "Resource not found"}), 404
|
||||
return jsonify(resources[resource_id]), 200
|
||||
|
||||
resource = resources[resource_id]
|
||||
logger.debug(f"Returning resource {resource_id}: {resource}")
|
||||
return jsonify(resource), 200
|
||||
|
||||
@app.route("/pay", methods=["POST"])
|
||||
def pay():
|
||||
logger.info("Received /pay request")
|
||||
data = request.json
|
||||
logger.debug(f"Pay request data: {data}")
|
||||
amount = data.get("amount", 0)
|
||||
transaction_id = f"tx_{int(datetime.now().timestamp())}"
|
||||
logger.info(f"Processed payment of {amount} with transaction ID: {transaction_id}")
|
||||
return (
|
||||
jsonify(
|
||||
{
|
||||
"transaction_id": f"tx_{int(datetime.now().timestamp())}",
|
||||
"transaction_id": transaction_id,
|
||||
"status": "success",
|
||||
}
|
||||
),
|
||||
200,
|
||||
)
|
||||
|
||||
|
||||
# Initialize model map on startup
|
||||
logger.info("Starting application initialization")
|
||||
initialize_model_map()
|
||||
|
||||
logger.info("Application initialization completed")
|
||||
|
||||
if __name__ == "__main__":
|
||||
logger.info("Starting Flask application on port 31337")
|
||||
app.run(debug=True, port=31337)
|
||||
logger.info("Flask application stopped")
|
||||
Loading…
Add table
Add a link
Reference in a new issue