Instructions to use nathishdev/destin-corporate-travel with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use nathishdev/destin-corporate-travel with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("text-generation", model="nathishdev/destin-corporate-travel", trust_remote_code=True)
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("nathishdev/destin-corporate-travel", trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained("nathishdev/destin-corporate-travel", trust_remote_code=True, device_map="auto")
messages = [
    {"role": "user", "content": "Who are you?"},
]
inputs = tokenizer.apply_chat_template(
	messages,
	add_generation_prompt=True,
	tokenize=True,
	return_dict=True,
	return_tensors="pt",
).to(model.device)

outputs = model.generate(**inputs, max_new_tokens=40)
print(tokenizer.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use nathishdev/destin-corporate-travel with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "nathishdev/destin-corporate-travel"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "nathishdev/destin-corporate-travel",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker

docker model run hf.co/nathishdev/destin-corporate-travel

SGLang

How to use nathishdev/destin-corporate-travel with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "nathishdev/destin-corporate-travel" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "nathishdev/destin-corporate-travel",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "nathishdev/destin-corporate-travel" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "nathishdev/destin-corporate-travel",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Docker Model Runner
How to use nathishdev/destin-corporate-travel with Docker Model Runner:
```
docker model run hf.co/nathishdev/destin-corporate-travel
```

Destin - Corporate Travel AI Assistant

🏨 Model Description

Destin is an AI-powered corporate travel assistant specialized in hotel search and booking. Built on Microsoft's Phi-3.5-mini-instruct and fine-tuned with LoRA, Destin understands natural language hotel queries and converts them into structured booking data.

Key Features

🎯 Natural Language Understanding: Parse complex hotel queries in conversational language
🏢 Corporate Travel Focus: Optimized for business travel scenarios
📊 Structured Output: Generates clean JSON for booking systems
💬 Conversational: Handles greetings, follow-ups, and clarifications
⚡ Fast: Optimized for production deployment

🚀 Quick Start

Installation

pip install transformers torch accelerate

Basic Usage

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

# Load model
model_name = "nathishdev/destin-corporate-travel"
tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,
    device_map="auto",
    trust_remote_code=True
)

# Generate response
def chat(query):
    prompt = f'''<|system|>
You are Destin, a corporate travel assistant.<|end|>
<|user|>
{query}<|end|>
<|assistant|>
'''
    
    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
    outputs = model.generate(
        **inputs,
        max_new_tokens=300,
        temperature=0.7,
        top_p=0.9,
        do_sample=True
    )
    
    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
    # Extract assistant response
    response = response.split("<|assistant|>")[-1].strip()
    
    return response

# Example queries
print(chat("Hi! Who are you?"))
# Output: I'm Destin, an AI assistant specialized in corporate hotel bookings...

print(chat("hotel bangalore whitefield under 6k dec 10-12"))
# Output: {"destination": {"city": "Bangalore", "area": "Whitefield"}, ...}

💡 Use Cases

1. Hotel Search Parsing

query = "urgent booking mumbai bkc tonight under 8000"
result = chat(query)
# Extracts: city, area, date, budget, urgency

2. Conversational Booking

query = "I need a hotel in Delhi"
response = chat(query)
# Asks for: dates, budget, area preferences

3. Multi-City Travel

query = "hotels in bangalore dec 10-12 and mumbai dec 13-15, budget 6k each"
result = chat(query)
# Parses both destinations

📊 Model Details

Architecture

Base Model: microsoft/Phi-3.5-mini-instruct (3.8B parameters)
Fine-tuning Method: LoRA (Low-Rank Adaptation)
Trainable Parameters: 8.9M

Performance

Inference Speed: 30-40 tokens/second (FP16 on A10G GPU)
Memory Usage: ~8GB GPU RAM (FP16)
Response Time: 5-10 seconds per query

Training Dataset

The model was trained on:

Identity & personality examples (30)
Hotel query parsing (80)
Conversational flows (20)
Edge cases (typos, vague queries) (20)

🎯 Capabilities

What Destin Can Do

✅ Parse hotel search queries into structured JSON
✅ Handle natural language (typos, abbreviations)
✅ Understand dates (relative and absolute)
✅ Extract location, budget, guests, urgency
✅ Conversational follow-ups
✅ Multi-city trip planning

Supported Formats

Input Examples:

"hotel bangalore under 5k next week"
"urgent booking mumbai tonight"
"need accommodation in delhi aerocity for 3 nights"
"cheap hotel gurgaon cyber city for 2 people"

Output Format:

{
  "destination": {"city": "Bangalore", "area": "Whitefield"},
  "dates": {"check_in": "2024-12-10", "check_out": "2024-12-12"},
  "budget": {"max_per_night": 6000, "currency": "INR"},
  "guests": {"adults": 1}
}

🔧 Integration Examples

FastAPI Deployment

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class QueryRequest(BaseModel):
    query: str

@app.post("/parse")
async def parse_query(request: QueryRequest):
    response = chat(request.query)
    return {"response": response}

MCP (Model Context Protocol)

# Compatible with MCP for agent workflows
# Use Destin as a tool in multi-agent systems

📈 Roadmap

Flight booking support
Cab/transport integration
Multi-language support
International destinations
Real-time price integration

🤝 Contributing

Feedback and suggestions welcome! Open an issue or PR.

📄 License

MIT License - Free for commercial use

Acknowledgments

Base model: Microsoft Phi-3.5-mini-instruct
Training platform: Kaggle (free GPU)
Fine-tuning: LoRA + BitsAndBytes

Built with ❤️ for corporate travelers

Downloads last month: 7

Safetensors

Model size

4B params

Tensor type

F16

Model tree for nathishdev/destin-corporate-travel

Base model

microsoft/Phi-3.5-mini-instruct

Adapter

(716)

this model