Budget: 10000 USD Deadline: 10 days

Hello! I have done similar things — a GPT assistant on FastAPI with dialogue memory and connection to an external API (searching and providing data based on client requests). Auto-detection of language and a system prompt for the manager role is not a problem. Regarding Tourvisor: do you already have access to their API with documentation, or does that also need to be arranged? This affects the start.

Budget: 25 USD Deadline: 1 day

Hello! We can develop an AI assistant for a travel agency with Tourvisor API integration turnkey: backend, OpenAI integration, tour search, dialogue history, admin panel, Docker, and documentation.

We offer the stack:
— Python + FastAPI;
— OpenAI API / GPT model;
— PostgreSQL for dialogue history, logs, and settings;
— Docker;
— Swagger / OpenAPI;
— modular architecture for Telegram, WhatsApp, Instagram Direct, and website.

We will implement logic where the assistant independently conducts a dialogue with the client, determines the language of communication, collects the necessary tour parameters, calls the searchTours() function, retrieves real offers from Tourvisor, and formulates a response to the client based solely on them.

Important: the assistant will not invent prices, availability, or hotels. All offers will be based only on data from the Tourvisor API.

We will also create a simple admin panel:
— editing the system prompt;
— managing the knowledge base;
— viewing dialogue history;
— request and error logs;
— monitoring integration performance.

The architecture will be designed with the possibility of further expansion. We can fix the cost accurately after reviewing the Tourvisor API documentation, dialogue scenarios, and admin panel requirements.

At the end, we will provide the source code, Docker configuration, launch instructions, API documentation, and assist with the first deployment. Please write in private messages. Expand

Budget: 500 USD Deadline: 10 days

Hello Zhasulan,
I'm Hiroshi, a developer based in Japan working with AI and backend systems.
A client writes I want to go to Turkey, the assistant politely asks about dates and budget, then a few messages later names a hotel and a price that do not actually exist in Tourvisor, because the API responded with something other than expected at that moment and GPT simply finished a plausible sounding answer instead of stopping.
The happy client books, calls to confirm, and the agency ends up with an angry person instead of a lead.
I understand the real task here is not the conversation itself, it is making sure the assistant never says anything that is not in the real Tourvisor data.
What I would own is the entire backend and the architecture around it.
I build a FastAPI service with a REST API and Swagger, store conversation history and data in PostgreSQL, implement function calling with a dedicated searchTours function, detect the client's language on every message rather than only at the start, and put together a simple admin panel for the system prompt, knowledge base, history and logs, all running in Docker.
There is a point worth building in from the very start.
A model will always finish a plausible answer by nature if the Tourvisor data comes back empty, partial or delayed, so the rule against inventing prices and tours cannot live only in the system prompt, it has to be enforced in code, and if searchTours returns nothing or an incomplete result the assistant must say so directly instead of shaping a nice sounding but invented answer.
I design the architecture as modular from day one, so Hot Tours, Hotel Descriptions and later WhatsApp, Telegram, Instagram Direct and the website plug in without rewriting the core logic.
I work with OpenAI, Gemini and Claude APIs in real products, including a structured prompt generation interface for Gemini, and with the WhatsApp Business API.
I hope we can talk here about the details of the project, and one question would help right away with scoping.
Does Tourvisor already have test access and documentation for the tour search API, or is that also something to arrange along the way.
An assistant is only as good as how honest it is with the client, and that honesty is exactly what I build into the architecture from day one. Expand

Budget: 250 USD Deadline: 10 days

Hello!

I will build this AI manager turnkey: FastAPI + OpenAI Function Calling, Tourvisor as the sole data source for tours.

Regarding the stack and logic:
- Python (FastAPI), PostgreSQL, Docker, Swagger, as you requested. REST API exposed, so that later WhatsApp, Telegram, Instagram, or a website can be attached without touching the core.
- The dialogue is conducted by GPT through tools: currently searchTours(), later searchHotTours() and getHotelInfo() will be added as new functions, while the application logic remains unchanged.
- Russian and Kazakh are determined automatically.
- Against fabrications: the model does not generate prices and availability from thin air. It retrieves results from Tourvisor as structured data from the tool and only formats them. What is not in the API response will not be in the client response.
- Admin panel: system prompt, knowledge base, dialogue history, logs, and errors.

Experience: I write bots and integrations in Python, I have live demos. Ready to share in chat so you can experience the flow before the solution.

A question regarding the matter: the search in Tourvisor is asynchronous, first a request, then polling by requestid until all operators are pulled in. How to behave in the dialogue: keep the client until the full output or provide the first offers immediately and supplement? And do you already have partner access (authlogin/authpass)?

Price and timeline: $250, 10 days for the first stage (searching for tours, admin panel, Docker, documentation, assistance with the first launch). I set a starting price: I am gathering initial reviews on Freelancehunt, so I am making it advantageous.

Petr Pankov, BotCraft Group Expand

Budget: 400 USD Deadline: 10 days

Zasulan, the task is clear: an AI manager is needed that conducts dialogue, does not invent prices and tours, but relies only on Tourvisor and the history of correspondence. I would build a modular backend on FastAPI with REST API, function calling, PostgreSQL, and Docker, so that Telegram, WhatsApp, and new APIs can be connected in the future without rework. I have 7 years of experience in web services and team development. I am ready to discuss the logic and architecture.

Budget: 500 USD Deadline: 7 days

Hello. I implement backend on FastAPI/Python. Ready for collaboration!)

Budget: 400 USD Deadline: 10 days

Hello, my name is Nikita.
I am ready to develop an AI manager for a travel agency using FastAPI with integration of OpenAI and Tourvisor.

I have already created similar AI assistants with function calling, where the bot collects the necessary data from the client and calls external APIs without inventing prices.
I will create a simple admin panel for managing prompts and history, and I will design the architecture to be modular for future messengers.
Portfolio: Freelancehunt

Estimated price, timeline: 400 USD, 7-10 days.
Write to me, and we will work together.

Budget: 25000 USD Deadline: 35 days

Look, there's a nuance - this is a specialized task for us, because this is not just a chat, but an AI manager with a server part, Tourvisor API, dialogue history, admin panel, logs, and a proper modular architecture.

Regarding the timeline and budget - the target is 240,000 UAH and 35 days for the first working phase. I plan to include FastAPI, PostgreSQL, Docker, Swagger/OpenAPI, REST API, OpenAI integration, searchTours(), an admin panel for prompts and knowledge bases, viewing history, logs, and errors.

For the technical part, I would build the core so that the dialogue logic is separate from the communication channels. Then the website, WhatsApp, Telegram, Instagram Direct, or another channel can be connected through separate adapters, while Tourvisor Search Tours, Last-Minute Tours, and Hotel Descriptions remain separate functions. !!The model should not invent prices, availability, and tours!! - only data from the Tourvisor API, followed by a careful formulation of the response to the client.

From you at the start, I need access and documentation for the Tourvisor API, a sample knowledge base for the agency, requirements for roles in the admin panel, and the choice of the first launch channel - only API or also a web chat. It's better not to complicate things here, but the boundaries need to be checked in detail; otherwise, the estimate will be pretty but not useful =/

I will clarify 2 questions:
> Is the first launch needed as a REST API for future channels, or is a ready web chat needed on the site?
> Will the knowledge base be in the form of documents, tables, FAQs, or is there already a structure for uploading to the admin panel?

Based on similar experience:
> https://business.ingello.com/vorfahr - AI automation and product logic with external actions
> https://business.ingello.com/svitbus - booking, searching for offers, roles, final business logic
> https://business.ingello.com/fractal - modular agent architecture, indirectly close to expanding assistant functions

Ingello Systems on Freelancehunt - https://systems-fl.ingello.com Expand

Budget: 2000 USD Deadline: 7 days

Hello, I worked on an AI assistant for a rental service — integration of OpenAI + external APIs, saving chat history, auto language detection, FastAPI + PostgreSQL + Docker. A similar architecture to your task.

Question: is there already access to the Tourvisor API (keys, documentation), and is there a plan to connect messengers right at the first stage, or later?

I suggest we get in touch; I will provide you with free technical consultation and we can create a development plan + I will tell you about my team!

Budget: 450 USD Deadline: 10 days

Hello! I am very interested in your project for developing an AI manager for a travel agency. I have deep expertise in building architecture on FastAPI and integrating external APIs, such as OpenAI and booking services. Recently, I left a large IT company where I was involved in developing complex enterprise systems to start my own practice on this platform. Since I am currently actively building my portfolio and working on getting my first reviews, I offer to complete your order with the highest professional quality at a significantly more pleasant price. I guarantee clean code, reliable integration with Tourvisor, and stable operation of your AI assistant. Please let me know if you already have API keys for accessing Tourvisor, and if integration with specific messengers (Telegram/WhatsApp) is needed at the MVP stage? I look forward to your response to discuss the details. Best regards, Maxim.

Budget: 600 USD Deadline: 7 days

😀 Hello!
✅ I will perform quality work 👌
✅ I have done similar work before — AI agents/chatbots on LLM + integrations 🎯
🛠 How I will do it: AI manager (chatbot) for the tourism sector — responses to inquiries, tour selection, application collection; integration with your channels (website/Telegram/Instagram) and CRM, knowledge base tailored to your data. Admin panel + training on your materials
🎥 Portfolio: Freelancehunt
✅ Feel free to reach out, we will discuss the details 👌🙂

Budget: 150 USD Deadline: 2 days

Hello! I am ready to develop an AI assistant for a travel agency using Python/FastAPI with integration of OpenAI GPT-5.5 and Tourvisor API.

I will implement a dialogue in Russian and Kazakh, history storage, a system prompt, and a knowledge base, Function Calling for searchTours(), obtaining real offers from Tourvisor without generating fictitious prices/tours. I will make the architecture modular for future integration with Telegram, WhatsApp, Instagram, the website, as well as the API for last-minute tours and hotels.

I will include PostgreSQL, Docker, Swagger/OpenAPI, a web panel for prompts, knowledge bases, dialogues, and logs. I will provide the source code, documentation, and assist with the first launch.

GPT-5.5 supports Function Calling, so the scenario with safe calling of the Tourvisor API will be implemented correctly. OpenAI documentation.

Budget: 750 USD Deadline: 10 days

Good day.
I am ready to take your project into work.
I can develop such a bot for you using low-code tools.
Message me privately, and we will discuss all the nuances of your technical specifications and find the best solution for you.

Budget: 350 USD Deadline: 21 days

I will create an assistant on FastAPI: a dialogue through OpenAI with Function Calling, searchTours as the first tool, hot tours and hotel descriptions will then be added as new features without reworking the core. PostgreSQL for dialogue history, Docker, Swagger, an admin panel with prompts, a knowledge base, history, and logs.

Prices and availability are taken only from the structured response of Tourvisor: the model formats the request result, rather than writing it from scratch. The search in Tourvisor is asynchronous, results take a few seconds to gather, so in the dialogue, there is a normal wait time, allowing the client to see that the selection is in progress, rather than the bot freezing.

And one thing that is more important for the travel agency than technology: clients who viewed tours and disappeared are not lost. The bot saves the request and contact, the manager sees warm clients in the admin panel and can follow up with them manually.

I will test the auto-detection of language and responses in both languages on test dialogues before delivery to ensure it works stably, not just in demo mode.

We will discuss the details in the chat.

Budget: 650 USD Deadline: 14 days

I understood the technical specifications: a backend on FastAPI that conducts a dialogue through OpenAI (system prompt plus knowledge base), collects trip parameters from the client, calls the Tourvisor API for real tours via function calling, and provides GPT with a well-formatted response—without fabricated prices and locations.

I have already built such an architecture for a voice AI assistant for veterinary clinics: LLM as an orchestrator with tool use, RAG search through the knowledge base, and a strict rule that the model cannot invent facts, only what the external API returns. The difference here is that instead of telephony, it's a text chat, and instead of my own database, it's Tourvisor, but the principle is identical.

I will create a FastAPI backend with a REST API, function calling for searchTours() with a foundation for future searchHotTours() and getHotelInfo() without rewriting the architecture, PostgreSQL for dialogue history and logs, Docker wrapping for deployment, and a simple admin panel on FastAPI for prompts, knowledge base, and logs.

Modularity for WhatsApp, Instagram, and Telegram will be laid out from the beginning at the level of communication channel abstraction so that adding a new messenger does not affect the dialogue logic.

Regarding timelines—after clarifying the scope of the first version (how many clarification scenarios for the AI, how complex the admin panel is), I will provide a specific estimate, approximately 2-3 weeks for the MVP with this set of functions.

Budget: 600 USD Deadline: 20 days

Hello. I have done something similar — a consulting bot on FastAPI with function calling, where GPT called an external API and responded only with its data, so the specifics of the task are familiar.

Essentially: core on FastAPI + Postgres, history of dialogues in the database, so the assistant does not lose context. I make searchTours() as a tool for the model — it collects the departure city, dates, composition, and budget from the client, and only then does the request to Tourvisor. The response to the client is strictly compiled from what the API returned. If there are no tours — it will say so and suggest adjusting the dates. Inventing prices is cut off both by the prompt and at the code level: the models simply have no way to get numbers other than from the Tourvisor response.

Regarding expansion — I will wrap Tourvisor in a separate adapter, last-minute tours and hotel descriptions will then be added as a couple more functions, the core will not need to be rewritten. The same goes for channels: the core provides a REST API, while WhatsApp/Telegram/website are thin connectors on top. I can set up Telegram right away, it's convenient to test on live dialogues.

Russian/Kazakh — the model itself determines the language of the message and responds in it, nothing extra needs to be built, I will check it with Kazakh requests.

The admin panel will be simple: the prompt and knowledge base can be edited from the browser and picked up without a restart, dialogues and error logs can be viewed there as well.

I will provide the code, docker-compose, instructions, and Swagger, and I will help with the first launch on your server.

Two questions: do you already have the Tourvisor key? And from which channel are we starting — messenger or website?

In terms of timelines — about 3-4 weeks with testing on real requests. Expand

Budget: 600 USD Deadline: 18 days

Hello!

I can implement this project.

Experience:
— Python, FastAPI
— OpenAI API / Claude API — actively using, built AI assistants
— Telegram bots with AI integration
— PostgreSQL, Docker
— REST API development and integrations
— Function Calling (Tools) — have experience

What I will implement:
✅ FastAPI backend with REST API
✅ OpenAI GPT integration with dialogue memory
✅ Auto language detection (Russian/Kazakh)
✅ Tourvisor API integration (searchTours)
✅ Function Calling for searching tours
✅ Admin panel (prompts, knowledge base, logs, dialogue history)
✅ Modular architecture for future integrations (WhatsApp, Telegram, Instagram, hot tours, hotels)
✅ Docker configuration
✅ API documentation (Swagger)
✅ Launch instructions

Timeline: 14-18 days
Cost: $400-600

Ready to discuss the details. Expand

Budget: 380 USD Deadline: 7 days

Hello! I specialize in AI assistants and integrations with the OpenAI API. I will create a backend in Python (FastAPI) + PostgreSQL + Docker: a dialogue with memory history, automatic language detection, function calling for searchTours() via the Tourvisor API - the architecture is modular, so searchHotTours() and getHotelInfo() will connect without rework, as well as WhatsApp/Telegram/Instagram channels. Admin panel: editing the system prompt, knowledge base, dialogue history, logs. I will provide the code, Swagger documentation, Docker configuration, and assist with the first launch.

Budget: 700 USD Deadline: 12 days

Hello.
I have already worked with FastAPI services, OpenAI tools, knowledge bases, and external API integrations. For this project, a key point is to control the search at the backend level, rather than relying solely on the system prompt.
I will structure the dialogue so that the assistant first fills out a structured search profile: departure, dates, composition of tourists, budget, and preferences. The searchTours() function will only be called after mandatory data verification. The request itself, the response from Tourvisor, and the final status will be saved in the history, allowing for any dialogue to be checked and understanding why a specific option was provided.
The knowledge base will be used for agency rules, FAQs, and communication tone. Prices, hotels, and availability in the response will come only from Tourvisor. If the API returns an empty or incomplete result, the assistant will correctly continue to clarify, without fictional suggestions.
I will create a modular core on FastAPI + PostgreSQL: a separate layer for Tourvisor, OpenAI tools, history and logs, and a simple admin panel for prompts and the knowledge base. Telegram, WhatsApp, the website, and subsequent Tourvisor methods will then be connected via separate adapters.
Before starting work, I need to clarify: is there already access to the Tourvisor API and test responses, as well as which channel will be the first in the MVP?
In private messages, I can show relevant examples and discuss details.

Budget: 4500 USD Deadline: 6 days

Hello! I am ready to implement an AI manager for your travel agency. I have experience integrating AI into Telegram bots, including setting up a system prompt to support dialogue context and using tools (function calling) to obtain relevant data.

Here’s how I plan to implement this task:

I will build a flexible bot architecture on aiogram 3.x, which will allow easy processing of user requests and forwarding them to the OpenAI API.
I will implement an integration module with the Tourvisor API to search for tours based on user queries.
I will set up a "hallucination guard" mechanism so that the bot provides answers solely based on the provided data and API capabilities.
I will deploy the entire project on reliable hosting Railway, ensuring stable operation of the bot.
Please let me know if you already have documentation for the Tourvisor API or access keys so that I can better assess the scope of work for processing search results.

Budget: 4500 USD Deadline: 5 days

Hello!

I work cheaper than the market rate as I am currently actively building my portfolio.

I have experience with Python, FastAPI, OpenAI API, databases, and creating AI assistants.

From the project, I understand: an AI manager is needed for a travel agency that will conduct dialogues, collect client data, access the Tourvisor API, and show only real offers without fabricated prices and tours.

Estimated cost: 200 USD.

Deadline: 5 days.

I will confirm the exact cost and deadlines after clarifying a couple of details regarding the Tourvisor API and the format of the admin panel.

Feel free to write, I would be happy to discuss the project! Expand

Budget: 250 USD Deadline: 7 days

Hello! The main catch here is in Tourvisor itself: the search for tours is asynchronous; the first request only starts the selection and returns a requestid, while the actual offers are retrieved by a second request polling the status until it becomes finished. If you pull the result immediately, it will return empty. Therefore, searchTours() waits for readiness, and GPT receives a ready list and only formulates it in words; prices and availability are provided by the backend, not the model, so it cannot invent them. I determine the language (Russian/Kazakh) using the model itself in the system prompt, without a separate detector. I attach the messenger connectors and future searchHotTours/getHotelInfo to a common layer of adapters to allow for additions without modifying the core. I will gladly outline the structure of tools and the polling dialogue scheme for free in private. I look forward to collaborating.

Budget: 500 USD Deadline: 10 days

Hello!

The task is completely clear. Designing modular AI assistants with strict boundaries to eliminate "hallucinations" (fabricating prices and locations) is the right engineering approach.

I specialize in asynchronous development in Python (FastAPI) and building reliable infrastructure in Docker. I am ready to implement this project from scratch, laying down a scalable architecture.

How I will implement the key requirements:

Elimination of hallucinations (OpenAI Tools / Function Calling): I will write a strict system instruction and connect functions through the tools mechanism. GPT will not invent data: upon encountering a search request, the model will be required to call the function searchTours(), the backend will retrieve real data from the Tourvisor API, and only based on that will the AI form the final response.

Modularity and scalability (Clean Architecture): I will design the backend based on the principle of loose coupling. The core AI logic, integration with Tourvisor, and message delivery interfaces will be separated. This will allow for seamless addition of functions searchHotTours() / getHotelInfo() later, as well as connecting adapters for Telegram, WhatsApp, or a website widget without rewriting the core.

Admin panel: I will implement a lightweight and responsive web panel for managing the system prompt, dynamically loading the knowledge base (via a vector embedding storage or text context), as well as logging dialogues and sessions.

DevOps & Documentation: Full containerization through Docker/Docker Compose (deployable with one command), PostgreSQL database with proper indexing of dialogue histories, and a fully auto-documented API via Swagger (OpenAPI).

Estimated assessment:

Timeline: 10–14 days (considering the design of a flexible architecture for future messengers).

Budget: I am ready to discuss the exact figure after a detailed acquaintance with the Tourvisor API (around $500–$700 depending on the volume of the knowledge base and admin panel).

My background and code quality can be assessed in my portfolio on GitHub: https://github.com/kamedashe/Bohdan-Betskov-Portfolio.

I would be happy to discuss the dialogue structure and logic of working with the API in a call or chat! Expand

Budget: 350 USD Deadline: 30 days

Hello!

I can implement an AI assistant for a travel agency: OpenAI GPT-5.5 + Tourvisor API, dialogue with the client, gathering tour parameters, and responses based solely on real data from the API (no fabricated prices or availability).

Experience:

Production AI assistant (Telegram → OpenAI → function calling → external APIs): dialogue, tools, rule "do not fabricate data."
FastAPI, PostgreSQL, Docker, Swagger — main stack.
React admin — prompt, knowledge base, history, logs.
Telegram bots in production; I will make the architecture modular (WhatsApp / Telegram / website — separate adapters).
Tourvisor: no direct experience yet, but there are integrations with external APIs. Initially — "Search tours" via searchTours(); interface for searchHotTours() and getHotelInfo() without rewriting the core.

MVP (~2.5–3 weeks): backend + dialogue (RU/KZ) + Tourvisor + admin + one channel (Telegram or web).

I will provide: code, Docker, API documentation, instructions, assistance with the first launch.

Questions: which channel for MVP? are there Tourvisor keys? knowledge base format?

Architecture:
[Telegram / WhatsApp / Web Widget]
↓
Channel Adapter (thin layer)
↓
Chat Service (history, session, language RU/KZ)
↓
OpenAI Agent (GPT-5.5 + system prompt + KB)
↓ function calling
Tools: searchTours() | searchHotTours()* | getHotelInfo()*
↓
Tourvisor Client (REST)
↓
PostgreSQL (dialogues, logs, prompt, KB)
↓
Admin Panel (React) Expand

Budget: 1000 USD Deadline: 8 days

Hi there,

I have solid experience building AI assistants with OpenAI APIs, FastAPI, PostgreSQL, and modular backend architectures.

✔ GPT-5.5 integration with conversation memory and multilingual support (Russian/Kazakh)
✔ Function Calling approach for `searchTours()` and future extensions (`searchHotTours`, `getHotelInfo`)
✔ Tourvisor API integration using only real tour data — no fabricated prices or availability
✔ Admin panel for prompts, knowledge base management, chat history, logs, and errors
✔ Dockerized deployment, REST API, Swagger documentation, and clean modular structure

I understand the importance of designing the system for future integrations with WhatsApp, Telegram, Instagram Direct, and website channels without major refactoring.

Would be glad to discuss the architecture and help build a scalable travel AI assistant.

Thanks. Expand

Budget: 300 USD Deadline: 7 days

Good day. I will implement the OpenAI API integration with Tourvisor for searching tours and will deploy the backend on Nest.js with Docker-compose, which will allow for quick integration with Telegram and WhatsApp. I am ready to discuss the details and start working. I look forward to collaborating.

Budget: 92 USD Deadline: 5 days

Hello. I understood the task: an AI manager on GPT with dialogue in Russian/Kazakh, Function Calling for searchTours() via Tourvisor, and a modular architecture to later add searchHotTours(), getHotelInfo(), and channels (Telegram, WhatsApp, website) without reworking the core. I will create a FastAPI backend with REST API, a separate service layer for Tourvisor (so that new API methods connect as new function tools, not by modifying logic), PostgreSQL for dialogue history and logs, prompts and knowledge base as editable entities through a simple admin panel. An important point from the specifications will be taken literally: GPT generates only the text response based on real data from Tourvisor, without assumptions about prices and availability. I am ready to assemble and deliver the project with Docker and documentation in about 5 days. Please clarify: is access to the Tourvisor API (login/password for the XML interface) already available, or does it also need to be arranged?

Budget: 300 USD Deadline: 5 days

Hello!

I am ready to implement the backend for your AI assistant in Python (FastAPI) [or Node.js, if you choose it]. I have experience creating AI agents based on OpenAI models using the Function Calling (Tools) mechanism, which is critically important for your task.

Budget: 2000 USD Deadline: 21 days

Stage 1. Basic architecture and integration of messengers
Creating a reliable foundation for the project with an eye on further scaling (connecting Telegram, WhatsApp, Instagram).
Setting up the Python environment (FastAPI), initializing PostgreSQL.
Designing the database structure (users, sessions, chat logs).
Developing a unified gateway (REST API) for receiving messages (preparing for messenger webhooks).
Estimate: 20 hours | Cost: $500

Stage 2. AI core and dialogue logic (The most important stage)
Implementing communication logic, context retention, and protection against fabricated data.
Integrating OpenAI API (gpt-4o).
Setting up Function Calling (strict boundaries for AI to avoid inventing prices and to gather parameters: dates, budget, city).
Implementing a "memory" mechanism (saving the context of conversations in the database and passing it to OpenAI).
Automatic language detection (RU/KZ) and adapting the system prompt.
Estimate: 30 hours | Cost: $750

Stage 3. Integration of Tourvisor API
Linking the "brain" of AI with the real tour database.
Writing a connector to Tourvisor API (method searchTours).
Processing JSON responses from Tourvisor and formatting them for transmission to OpenAI.
Testing the chain: Client request $\rightarrow$ AI $\rightarrow$ Tourvisor API $\rightarrow$ AI $\rightarrow$ Client response.
Estimate: 20 hours | Cost: $500

Stage 4. Admin panel and Knowledge Base
Interface for managing the bot without programmer involvement.
Developing a web panel (based on ready-made solutions FastAPI-Admin or a lightweight template).
Module for editing the system prompt.
Module for uploading the Knowledge Base (instructions, regulations) and setting up contextual search (RAG).
Interface for viewing chat history and errors.
Estimate: 25 hours | Cost: $625

Stage 5. Packaging, Deployment, and Documentation
Preparing the project for handover to the client according to the specifications.
Generating automatic API documentation (Swagger/OpenAPI).
Writing Dockerfile and docker-compose.yml for one-click deployment.
Writing instructions for launching and setting up environment variables (.env).
Test launch on the client's server.
Estimate: 15 hours | Cost: $375

Implementation period: 3-4 weeks Expand

Budget: 500 USD Deadline: 12 days

Hello! The task is similar to what I have already done — AI sales agents with function calling over external APIs and strict control to "not make up data" (assistant for realtors, AI seller for Telegram/Instagram with retrieval from the catalog). Architecture: FastAPI + PostgreSQL + Docker, clear separation of the dialogue layer (OpenAI + function calling), integration layer (Tourvisor), and data layer — this aligns with your requirement for modularity and future expansion (Last-minute tours, Hotel descriptions, messengers) without needing to redo the foundation.
Logically: searchTours() as the first tool, the GPT response is gathered only from real data from Tourvisor (without "fantasies" about prices/locations) — this is implemented through a strict system prompt + validation that the model does not respond without calling the tool.
Admin panel: prompt, knowledge base, dialogue history, logs — I will create a simple web panel on FastAPI+Jinja or a lightweight React to keep it straightforward.
Please clarify: is there already access and documentation for the Tourvisor API? Is Telegram/WhatsApp needed right away in the MVP, or should we start with the web chat/API core?

Budget: 650 USD Deadline: 25 days

Your project can be implemented using Python and FastAPI, which will ensure service performance of up to 1000 simultaneous requests. For integration with OpenAI and Tourvisor API, I propose an architecture with REST API and Docker, which will simplify deployment and scaling. I will provide code examples and architectural diagrams that will help you better understand how the system will work. Message me privately, and I will send you the details.

Budget: 1200 USD Deadline: 18 days

Hello, Zhasulan.
This dangerous error occurs not only when GPT invents a price. It may misunderstand dates, departure city, budget currency, or forget the child's age, after which Tourvisor will return real tours, but not at all according to the client's request.
Therefore, I would separately control the search parameters: the assistant collects mandatory data, the backend checks it, and only after that calls searchTours(). The history saves the request itself, the Tourvisor response, and the conditions under which the search was performed. If there is insufficient data or no suitable tours, the assistant clarifies the request instead of filling in the gaps on its own.
In 5 days, I can show the first working outline: a dialogue in Russian and Kazakh, parameter collection, calling searchTours(), and a response based on real Tourvisor data. After verifying this scenario, I will add a knowledge base, history, prompt management, logs, and a simple admin panel.
I work with Python backend, OpenAI tools, external APIs, and systems where the model must act only on the given data. I have created AI consultants, Telegram systems, knowledge bases, admin panels, and dialogue logging.
Stack: FastAPI, PostgreSQL, OpenAI API, Docker. The core of the dialogue will be separated from the channels, so Telegram, WhatsApp, and the website will later connect to the same REST API without rewriting the main logic.

Source files, Docker, Swagger, instructions, and help with the first launch are included.

Is there already working access to the Tourvisor API and test examples of its responses?

Budget: 1234 USD Deadline: 1 day

Good day! I have relevant experience in performing similar tasks. I am ready to discuss the details and start working.

Budget: 675 USD Deadline: 5 days

Ready to take on this project. I see that an AI manager is needed for a travel agency with OpenAI API integration — to engage in dialogue with clients, search for tours through Tourvisor, and not invent prices. The stack fits the task: FastAPI + PostgreSQL + Docker.

What I will do:
• Set up a FastAPI backend with endpoints for chat dialogue
• Configure OpenAI Function Calling — the model will call functions to search for tours
• Connect Tourvisor as the sole data source (prices, destinations, hotels)
• Save chat history in PostgreSQL — so context is not lost between sessions
• Package everything in Docker-compose — it will run with a single command

I have completed all current projects and am now fully available — I will start today and focus solely on your task. No downtime.

After delivery, I won't disappear — I will stay in touch, helping with edits and updates. Message me — and I will draft a plan for the first stage in 10 minutes. Expand

Budget: 350 USD Deadline: 10 days

Hello! I have excellent experience in developing AI assistants and integrating language models through OpenAI Function Calling (Tools), so I am ready to implement your project turnkey. I will carry out the development strictly according to your requirements in Python (FastAPI) + PostgreSQL + Docker.

How I will implement key tasks:
AI Logic and Tourvisor: I will configure Function Calling so that the model clearly collects parameters (city, dates, family composition) and calls the function searchTours(). The AI will not hallucinate or invent prices, as the final response will be based solely on raw current data from your Tourvisor API.

Modular Architecture: I will design the project based on the principle of service architecture. The AI layer, Tourvisor layer, and future integration layer will be isolated. This will allow you to easily add methods for last-minute tours/hotels in the future, as well as connect inputs from Telegram, WhatsApp, or a web widget.

Admin Panel and Logs: I will create a concise web panel for the operational update of the system prompt, knowledge base, and convenient viewing of logs/conversations.

Important note about the API: Since Tourvisor is a paid commercial system, we will need your active API keys for the development and testing phase.

Budget: 200 USD Deadline: 1 day

Hello!

We can develop an AI assistant for you with integration tailored to your task.

1. Do you need an admin panel for prompts, knowledge base, and logs right away?
2. Is there a plan to connect WhatsApp, Telegram, or a website in the first phase?

—
About us

We are dZENcode – a full-cycle IT development company: from design and programming to integrations and post-release support of digital solutions.
We create projects from scratch, as well as connect to existing solutions that need refinement, development, or technical support.

You can find detailed information about our services and rates on our official website: Freelancehunt

Take a look – after that we can discuss the details and agree on the next step.

⚠️ After clarifying all the details, we will determine the scope of work, the suitable format of cooperation: task-based, outsourcing, or outstaffing – and the final cost.

With us, projects are guaranteed to reach release:
• 10+ years providing IT services;
• 90+ in-house specialists;
• 250+ public reviews since 2015;
• We support products under SLA after launch;
• We work under NDA and contract with the company! Expand

Budget: 1100 USD Deadline: 21 days

Good day, I see the need for an AI manager for a travel agency with integration of the Tourvisor API and GPT - this is exactly the stack and approach I am working on. I will implement the backend on FastAPI, integration with OpenAI (Function Calling for searchTours and subsequent methods), dialogue logic with context memory and language detection, as well as a simple admin panel for managing prompts and the knowledge base. I have over 5 years of experience with Python/FastAPI and OpenAI API, having created AI assistants and Telegram bots with similar architecture. I will make the architecture modular - so that Telegram, WhatsApp, or the website can connect without reworking the core. Which platform is a priority for the first channel - website, Telegram, or something else? I look forward to your message in private!

Budget: 200 USD Deadline: 7 days

Get an AI manager that conducts conversations, gathers tour parameters, and returns real offers from Tourvisor — without fabricated prices and non-existent places.

I built LLM agents with Function Calling on OpenAI: the agent decides when to call an external API, retrieves data, and sends it back to GPT to form a response to the client. This scheme covers searchTours() and will allow for the addition of searchHotTours(), getHotelInfo() in the next stages without reworking the logic.

I will make the architecture modular — a separate layer for integrations, dialogue, and transport, so that Telegram, WhatsApp, or the website can connect without changes to the core. FastAPI, PostgreSQL, Docker. Admin panel: editing the system prompt, uploading the knowledge base, dialogue history, logs, and errors.

We will agree on the final cost after clarifying the details — write to discuss the scope.

Budget: 1000 USD Deadline: 13 days

Hello, Zhasulan! My name is Nina, I am a manager. My Full-Stack/AI developer will implement a fault-tolerant AI manager strictly according to the specifications in Python (FastAPI). He has extensive experience in building agent workflows, and he will make the architecture fully scalable.

How he will implement the project:
Strict Function Calling: We will configure the AI so that the function searchTours() is called only when all 7 mandatory parameters (city, dates, family composition, etc.) are collected. Until then, the AI will conduct a gentle survey.
No hallucinations: We will strictly limit the system context of the model. Prices, hotels, and locations will be taken exclusively from the JSON responses of the Tourvisor API.
Modular architecture: We will isolate the integration with Tourvisor and future channels (WhatsApp, Telegram) into separate services. Adding new features will not affect the core.
Admin panel and database: We will set up PostgreSQL to store the history of dialogues with sessions. We will create a neat web panel for modifying prompts and viewing logs.
We will wrap the project in Docker, write Swagger documentation, and assist with deployment on your server.

Cost: $1000 USD
Deadline: 12–14 days (including database design and AI logic calibration) Expand

Budget: 750 USD Deadline: 10 days

Good day. I am developing
AI assistants turnkey. For this project
FastAPI + PostgreSQL + Docker — database
OpenAI GPT + Function Calling (searchTours/
searchHotTours / getHotelInfo) — dialogue with
the client, auto language detection, memory
history
Integration of Tourvisor API (tour search) —
real prices, no hallucinations
Web admin panel: prompts, knowledge base,
dialogue history, logs, errors
Modular architecture Telegram
WhatsApp / Instagram / website can be connected
without reworking the core
Deadline: 10-12 days
Price: 30,000 JMD (fixed, secure
transaction)
Experience: @MRAi_Demo_Bot — AI bot with RAG,
admin panel, production stack (Docker,
PostgreSQL, DeepSeek/OpenAI).
Ready to discuss details. Message me privately. Expand

Budget: 400 USD Deadline: 7 days

Hello!

I have extensive experience in developing AI agents.
I am ready to complete the assigned task.

I suggest we discuss the details in private messages.

Budget: 82 USD Deadline: 4 days

Hello. The task is clear: FastAPI backend with REST API, a dialog AI manager on OpenAI (I manage the chat history and language detection ru/kz through session context in PostgreSQL) and Function Calling with the function searchTours() as a separate tool — this immediately allows for later adding searchHotTours() and getHotelInfo() without reworking the dialog logic. I will implement a scenario for clarifying parameters (departure city, dates, adults/children with ages, budget, preferences) through a prompt with mandatory slots, and I will strictly formulate the response to the client based on data from Tourvisor — without assumptions about prices and availability. I will design the backend modularly (adapter layer for channels), so that Telegram/WhatsApp/website connect through separate connectors. The admin panel will allow editing the system prompt and knowledge base, viewing chat history and error logs. I will package everything in Docker with Swagger documentation and am ready to assist with the first launch. The deadline for the first version is around 4 days.

Budget: 1500 USD Deadline: 14 days

Hello! The project has a very clear and well-written specification. I am ready to implement it on FastAPI + Docker while adhering to all modularity requirements (flexible integration of messengers in the future without changing the core logic).

Total project cost: $1,500. I propose to break the work into three logical stages:

Stage 1 ($600): Basic backend + integration with OpenAI (Function Calling) + integration with Tourvisor API. The output: a working AI core that can gather data and search for real tours via API.

Stage 2 ($500): Admin panel (managing prompts, logging, uploading knowledge base) + saving chat history in the database.

Stage 3 ($400): Docker configuration, final testing, writing documentation, and assistance with deployment on your server.

Feel free to write, and we can discuss the details and I will start working. Expand

Budget: 2200 USD Deadline: 25 days

Hello, Zhasulan,

The essence of the project is in one requirement: the AI must not invent the price, hotel, or availability. Everything else follows from how to ensure this.

The guarantee here is that GPT does not create offers at all. It has only two tasks: to gather parameters in the dialogue and to format the results returned by Tourvisor. The data on tours never goes through the model's imagination. Specifically: searchTours() is a tool with a strict schema, and the model can only call it when the mandatory fields are filled: departure city, dates, adults, children with ages, budget, preferences. The API response is rendered, and if Tourvisor returns nothing, the assistant simply states that, rather than inventing an option.

The structure I will build:
- Backend on FastAPI, PostgreSQL for dialogue history and logs, Docker, Swagger documentation
- A registry of tools so that searchHotTours() and getHotelInfo() can later be registered alongside searchTours() without altering the dialogue logic
- Thin channel adapters separated from the core, so that WhatsApp, Telegram, Instagram Direct, and the website can later connect to the same assistant without rewriting
- Language detection (Russian and Kazakh), system prompt, and knowledge base loaded from storage, not hardcoded
- Admin panel: edit system prompt, upload knowledge base, view dialogue history, logs, and errors

Delivery as you specified: source code, Docker configuration, installation instructions, API documentation, and assistance during the first launch.

This is my main work: OpenAI and Claude API, FastAPI, function calling, API integrations. Statistics: 37 projects, all completed, rating 10/10.

Estimate: 2200 USD, about 25 days, I will clarify after I see the Tourvisor API documentation and gain access to your account.

One question that determines the dialogue scheme: does Tourvisor return search results asynchronously, meaning we start the search and then poll for readiness? If so, the assistant must carefully handle the waiting in the conversation, and it’s better to know this before designing this part.

Revaz Expand

Budget: 1000 USD Deadline: 4 days

Good day!
I can implement your idea as a microservice on Node.js (I have extensive experience, see my resume) and integrate it into your project/website.
Or build the project completely from scratch.
The completion time is from a couple of days to a week.

Budget: 400 USD Deadline: 6 days

Hello!!!

I am a backend developer and I write in Python (FastAPI) as it is better for an AI assistant.
I will teach the AI to fetch relevant data instead of making things up.
I will create a web panel.

Feel free to reach out.

Budget: 500 USD Deadline: 15 days

Hello.

Your project is a complete AI platform with the potential for further scaling. It is critically important to correctly separate the dialogue logic, GPT work, and integration with Tourvisor, so that in the future, without reworking, we can connect Hot Tours, Hotel Info, Telegram, WhatsApp, Instagram, and the website.

I propose to implement the backend on FastAPI with PostgreSQL, Docker, and Swagger. For interaction with GPT, we will use RAG and Function Calling, where the model will not be able to independently come up with tours, prices, or availability. The search will be performed only through the searchTours function, after which GPT will generate a response solely based on the data obtained from the Tourvisor API.

I will immediately build the architecture in a modular way with separate components for AI, Tourvisor API, knowledge base, dialogue history, admin panel, and future integration channels. This approach will allow adding new APIs and messengers without changing the core business logic.

The admin panel will allow changing the system prompt, updating the knowledge base, viewing dialogue history, error logs, and logging without making changes to the code.

Before starting development, I will prepare a small prototype for free. For example, I will implement the searchTours function and show the full cycle from the GPT request to receiving real offers from the Tourvisor API. If the approach and architecture suit you, we will continue the development of the entire project.

I would like to clarify if there is already access to the Tourvisor API?

At the first stage, is only the backend needed or is a web chat also required?

The cost of development starts from 500 USD. I will be able to provide an exact estimate of the timeline and budget after reviewing the Tourvisor documentation and clarifying the requirements for the admin panel. Expand

Budget: 200 USD Deadline: 3 days

Hello.
The main workflow will utilize OpenAI function calls (tools). I will implement the `searchTours()` function, which the artificial intelligence will call after gathering all the necessary client data — departure city, dates, passenger ages, budget, and preferences. Then, the server side will query the Tourvisor search API, and the results will be sent back to GPT-5.5 to create a well-crafted natural language response for the client, strictly using only real data from the API to avoid any fictional prices or availability.
To ensure the conversational AI operates effectively, I will implement a robust memory system to store conversation history sequentially. The system prompt will be carefully designed to guide GPT-5.5's behavior as a professional travel agency manager, with automatic language detection for Russian or Kazakh.
The documentation includes complete source code, Docker configuration, API documentation, and an installation guide. My experience with OpenAI and integrating travel APIs ensures a seamless development process and a future solution for your business.

Budget: 1000 USD Deadline: 10 days

Good day! I have extensive experience with Python/FastAPI, OpenAI API (Function Calling, AI assistants, knowledge bases, conversation history) and integrating external APIs. The architecture for such solutions is already almost ready, so I can quickly implement the project and plan for further expansion (Telegram, WhatsApp, new Tourvisor APIs) without reworking the main logic. After reviewing the documentation, I will be able to provide exact timelines and costs immediately.

Budget: 2000 USD Deadline: 30 days

Good day, Zhasulan

I am interested in your project. I have over 7 years of experience in development and practical experience in creating AI applications, integrating OpenAI API, building chat assistants, and complex backend systems. I also have practical experience specifically with Tourvisor in tour booking projects.

More details about my skills:
- development of AI assistants and LLM-powered solutions;
- working with Function Calling and RAG approaches;
- integration of external APIs and building scalable backend systems;
- development of solutions with further integration of Telegram, WhatsApp, and other communication channels.

I would immediately lay out the architecture with separate modules:
- AI Service;
- Conversation Service;
- Tourvisor Service;
- Knowledge Base Service;
- Integration Layer (Telegram/WhatsApp/Instagram);
- Admin Panel.
This approach will allow the project to evolve without serious rework in the future.

Technology stack:
Frontend: Next.js
Backend: FastAPI
Database: PostgresQL
Hosting: Vercel
Security: Cloudflare
Admin panel: Strapi or Payload CMS

Links to my recent works:
https://3dellora.com/
https://moduplans.com/en/
https://herdol.com/
https://www.jurisprudential.eu/en/
https://hgh.rts-developers.com/
https://nexoria.ai/
https://learnycorner.com/

I would be happy to discuss the details, propose the architecture, and help bring the project to a production solution 🙌 Expand

Budget: 3500 USD Deadline: 30 days

Hello! I have extensive experience in full-stack development (JavaScript/Node.js, PostgreSQL) and integration architecture with modern AI models using Function Calling and building autonomous agents.
I propose to implement your project on Node.js, which will ensure fast interaction with the Tourvisor and OpenAI APIs, laying a modular structure for easy integration of messengers in the future. I will take on the full cycle: from writing clean backend code and a user-friendly admin panel to deploying the project on your server with database optimization, ensuring the system runs stably and without hallucinations regarding prices.
Feel free to reach out, we will definitely come to an agreement.

Budget: 25000 USD Deadline: 30 days

We already have a practically ready foundation for such an AI manager, which can be quickly adapted for a travel agency and the Tourvisor API - we are in touch and can discuss the details here on the marketplace ))

In terms of timelines, I would estimate around 30 working days for the version with FastAPI, PostgreSQL, Docker, Swagger, dialogue history, an admin panel, a knowledge base, and tour searches through Tourvisor.

For the budget, the target is 180,000 UAH, more precisely after checking the Tourvisor documentation and the requirements for the admin panel.

Regarding the software architecture, I would create a separate layer of tools for AI - searchTours, and then without painful rework, add searchHotTours and getHotelInfo.

An important point - the model should not invent prices, places, or tours, so the manager's response is formed only after receiving real data from Tourvisor.

The admin panel can be kept simple - prompt, knowledge base, dialogue history, errors, and logs.

To launch, access to the Tourvisor API, an OpenAI key, an example of the desired tone of communication for the manager, and 5-10 typical dialogues with clients, if available, will be needed.

I would like to clarify two points.

- Is the Tourvisor API already connected, and do you have access to the documentation?
- At the first stage, is only a web chat needed, or should we already plan for a specific channel - Telegram, WhatsApp, Instagram Direct, website?

Relevant examples from Ingello.

- https://business.ingello.com/vorfahr - AI and automation of complex user scenarios
- https://business.ingello.com/fractal - agency logic and modular process automation
- https://business.ingello.com/svitbus - similar in logic to search, booking, and transport-tourist scenarios

Main page for FLH - https://systems-fl.ingello.com

Overall, it's a reasonable task; the main thing is not to try to create magic instead of engineering - measure seven times, give the model a tool call once =)

It seems the most sensible start is a working core with Tourvisor's tour search, dialogue journal, and a simple admin panel, while connecting channels can be done in the second stage without breaking the foundation. Expand

Budget: 200 USD Deadline: 5 days

Hello. I propose the implementation of your AI assistant on FastAPI with PostgreSQL and Docker, using patterns for integrating OpenAI GPT-5.5 and the Tourvisor API through Function Calling. The architecture will be modular, ensuring a clear separation of dialogue logic, data, and external services, which will allow for easy expansion of functionality and the addition of new messengers or APIs. I will ensure strict data validation and control of GPT's responses to avoid fabricated data, relying solely on information from the Tourvisor API. I have experience building similar assistants and ready templates for quick and quality development of core functionality and the admin panel. I suggest discussing all implementation details, final budget, and timelines in private messages.

Budget: 350 USD Deadline: 14 days

Ready to develop an AI assistant in Python using FastAPI and integrating the Tourvisor API. I will provide a modular architecture and documentation. I have experience working with the OpenAI API. Let's discuss the details!