from webscout import model
from rich import print
# List all available LLM models
all_models = model.llm.list()
print(f"Total available models: {len(all_models)}")
# Get a summary of models by provider
summary = model.llm.summary()
print("Models by provider:")
for provider, count in summary.items():
 print(f" {provider}: {count} models")
# Get models for a specific provider
provider_name = "PerplexityLabs"
available_models = model.llm.get(provider_name)
print(f"\n{provider_name} models:")
if isinstance(available_models, list):
 for i, model_name in enumerate(available_models, 1):
 print(f" {i}. {model_name}")
else:
 print(f" {available_models}")

from webscout import model
from rich import print
# List all available TTS voices
all_voices = model.tts.list()
print(f"Total available voices: {len(all_voices)}")
# Get a summary of voices by provider
summary = model.tts.summary()
print("\nVoices by provider:")
for provider, count in summary.items():
 print(f" {provider}: {count} voices")
# Get voices for a specific provider
provider_name = "ElevenlabsTTS"
available_voices = model.tts.get(provider_name)
print(f"\n{provider_name} voices:")
if isinstance(available_voices, dict):
 for voice_name, voice_id in list(available_voices.items())[:5]: # Show first 5 voices
 print(f" - {voice_name}: {voice_id}")
 if len(available_voices) > 5:
 print(f" ... and {len(available_voices) - 5} more")

from webscout import Meta
# For basic usage (no authentication required)
meta_ai = Meta()
# Simple text prompt
response = meta_ai.chat("What is the capital of France?")
print(response)
# For authenticated usage with web search and image generation
meta_ai = Meta(fb_email="your_email@example.com", fb_password="your_password")
# Text prompt with web search
response = meta_ai.ask("What are the latest developments in quantum computing?")
print(response["message"])
print("Sources:", response["sources"])
# Image generation
response = meta_ai.ask("Create an image of a futuristic city")
for media in response.get("media", []):
 print(media["url"])

from webscout import GROQ, DuckDuckGoSearch
import json
# Initialize GROQ client
client = GROQ(api_key="your_api_key")
# Define helper functions
def calculate(expression):
 """Evaluate a mathematical expression"""
 try:
 result = eval(expression)
 return json.dumps({"result": result})
 except Exception as e:
 return json.dumps({"error": str(e)})
def search(query):
 """Perform a web search"""
 try:
 ddg = DuckDuckGoSearch()
 results = ddg.text(query, max_results=3)
 return json.dumps({"results": results})
 except Exception as e:
 return json.dumps({"error": str(e)})
# Register functions with GROQ
client.add_function("calculate", calculate)
client.add_function("search", search)
# Define tool specifications
tools = [
 {
 "type": "function",
 "function": {
 "name": "calculate",
 "description": "Evaluate a mathematical expression",
 "parameters": {
 "type": "object",
 "properties": {
 "expression": {
 "type": "string",
 "description": "The mathematical expression to evaluate"
 }
 },
 "required": ["expression"]
 }
 }
 },
 {
 "type": "function",
 "function": {
 "name": "search",
 "description": "Perform a web search",
 "parameters": {
 "type": "object",
 "properties": {
 "query": {
 "type": "string",
 "description": "The search query"
 }
 },
 "required": ["query"]
 }
 }
 }
]
# Use the tools
response = client.chat("What is 25 * 4 + 10?", tools=tools)
print(response)
response = client.chat("Find information about quantum computing", tools=tools)
print(response)

from webscout.Extra.gguf import ModelConverter
# Create a converter instance
converter = ModelConverter(
 model_id="mistralai/Mistral-7B-Instruct-v0.2", # Hugging Face model ID
 quantization_methods="q4_k_m" # Quantization method
)
# Run the conversion
converter.convert()

Available Quantization Methods

Command Line Usage

python -m webscout.Extra.gguf convert -m "mistralai/Mistral-7B-Instruct-v0.2" -q "q4_k_m"