The post [CREANDO UN ROBOT — PARTE 1]- Enseñándolo a chatear first appeared on Planeta Chatbot.
]]>¿Qué está diciendo?
Lo primero que debemos entender es cuál es la naturaleza de hablar, charlar y del lenguaje. ¿Cómo alguien (o algo) construye una oración para demostrar un pensamiento y compartirlo con alguien más? (¡o algo más!) El estado del arte de este asunto es abundante y tendría que explicar un artículo completo solo para explicar cómo funciona. Si pudiéramos reducirlo a una cosa, esto sería el procesamiento del lenguaje natural, un tema de la inteligencia artificial que estudia cómo los robots pueden comunicarse con los humanos y viceversa. Si deseas profundizar en la filosofía de este asunto, te recomiendo los trabajos de un gran tipo llamado Noam Chomsky. Para un rápido vistazo de cómo funciona sugiero este artículo realizado por el Dr. Michael J.
Afortunadamente, tenemos un servicio que resume todas las complejidades y ofrece una herramienta muy intuitiva y fácil llamada DialogFlow. Es un gran producto hecho por Google para las personas que desean crear chatbots sin tener que enfrentarse a las complejidades de la PNL.
Para una explicación en profundidad de cómo funciona DialogFlow, sugiero buscar en sus documentaciones y contenido. Para evitar que este artículo sea demasiado denso, destacaré dos cosas a tener en cuenta al usar DialogFlow:
- Agente: es el tema principal de un chatbot se utiliza para mantener un “robot de chat” separado de otro, por ejemplo, puede tener un agente para cuestiones sobre objetivos o un agente que hable sobre el clima.
- Intención: es un segmento del asistente utilizado para describir la intención de la conversación. Si dices “adiós”, dialogFlow activa la intención de “adiós” y luego buscará respuestas dentro de este intent.
Tenen cuenta que hay muchas concepciones dentro de DialogFlow, estas dos son solo cosas extremadamente básicas cuando se habla del servicio de Chatbot de Google DialogFlow.
Un verdadero developer codifica el código
Basta de conceptos y explicaciones. Como hablar es fácil, ¡veamos el código! Para una integración real entre la API de Go y el servicio DialogFlow, sugiero revisar este artículo en el que se basa la mayor parte de mi trabajo. Por ahora, mostraré la parte de mi código que implementa la solución. ¡Bien! ¡Vamos allá!
El código completo se puede encontrar en mi GITHUB. Estoy usando algunos conceptos geniales como Arquitectura Hexagonal y SOLID modulation, si te parece algo desordenado o te falta algo, ¡dime tus observaciones! A continuación explico mi código:
main.go
package main
import (
"fmt"
"dunnorobot/cmd/routes"
"net/http"
"log"
"os"
)
func main() {
port := ":" + os.Getenv("PORT")
fmt.Println(port)
router := routes.CreateRouter()
log.Fatal(http.ListenAndServe(port , router))
}
Este es el código que contiene la instancia principal del servidor HTTP. Obtiene el PORT de la configuración de la variable de entorno y solicita la CreateRouter() función que crea un enrutador. Se utiliza un enrutador para que pueda envolver todos los puntos finales y la configuración del servidor en un solo objeto para una fácil manipulación (Pronto veremos más detalles). Después de crear tu enrutador, abre el servidor con el puerto y enrutador especificados.
router.go
package routes
import (
"github.com/gorilla/mux"
"dunnorobot/cmd/comunication/in"
"github.com/rs/cors"
"net/http"
)
func routes (router *mux.Router) http.Handler {
router.HandleFunc("/", inputInterface.HelloWorld).Methods("POST")
c := cors.New(cors.Options{
AllowedOrigins: []string{"*"},
AllowCredentials: true,
})
handler := c.Handler(router)
return handler
}
func CreateRouter() http.Handler {
router := mux.NewRouter()
routesWithHandlers:=routes(router)
return routesWithHandlers
}
Hay dos bibliotecas importadas, una es gorilla / mux. Una biblioteca utilizada para ajustar puntos finales y configuraciones y la otra es rs / cors utilizada para facilitar las configuraciones de cors.
En el CreateRouter() es la función llamada por el archivo main.go. Crea un enrutador mux y pasa a la función routes que coloca el contenido dentro de su objeto.
En la función, routes() primero manejo los puntos finales, ya que solo tengo un punto final, solo necesito escribir esta línea de código:
router.HandleFunc(“/”,inputInterface.HelloWorld).Methods(“POST”)
Primero dice qué punto final es: /luego dice qué función se activa:
por inputInterface.HelloWorld por último, pero no menos importante, se describe qué método activa la función:POST.
Luego está la configuración de Cors:
c := cors.New(cors.Options{AllowedOrigins: []string{"*"},AllowCredentials: true,})
Maneja la solicitud y comprueba si el que está haciendo la solicitud puede hacerlo. Considéralo como un “Servidor de seguridad de aplicaciones” (sé que no lo es, pero simular que es, ayuda a comprenderlo). En mi configuración de cors, estoy diciendo que cualquier método de cualquier origen está permitido, ya que mi aplicación no envía ninguna información confidencial que podría no tener problemas.
Dtos
package dtoInterface
type MessageStruct struct {
Message string
}
package dtoInterface
type MessageResponseStruct struct {
Response string
}
Dtos son los tipos, más específicos los objetos recibidos en la solicitud y la respuesta dada, son bastante simples pero es bueno saberlo y una buena práctica.
Ambos son extremadamente simples, solo una estructura con una sola variable, se hizo para mantener los conceptos de código limpio.
Input
package inputInterface
import (
"net/http"
"dunnorobot/cmd/comunication/service"
"encoding/json"
"dunnorobot/cmd/comunication/dto"
)
func HelloWorld (w http.ResponseWriter, r *http.Request) {
decoder := json.NewDecoder(r.Body)
encoder := json.NewEncoder(w)
var mObj dtoInterface.MessageStruct
err := decoder.Decode(&mObj)
if err != nil {
panic(err)
}
serviceResponse:=serviceInterface.PrimaryService(mObj)
var response dtoInterface.MessageResponseStruct
response.Response = serviceResponse
encoder.Encode(response)
return
}
Siguiendo la Arquitectura Hexagonal, esta es la entrada única que el servidor tiene que manejar. Recibe la entrada, decodifica el json y entrega su contenido a la función de servicio PrimaryService.. Obtiene su respuesta y se la devuelve al cliente.
NOTA: se implementó incorrectamente, este código se comporta más como un controlador que como una entrada de arquitectura hexagonal. Podría solucionar este problema lo antes posible. Sin embargo, funciona de todos modos.
Servicios
¡Finalmente! ¡Nuestro servicio! Aquí es donde realmente nos comunicamos con Dialogflow, enviamos el mensaje recibido y luego él devuelve una respuesta basada en la intención. La respuesta luego se devuelve a la persona que llama, que la envía de vuelta al cliente.
¡Se hace! ¡Con este código tenemos un CHATBOT!
Lo hice disponible en un servidor en la nube heroku, está en portugués pero es completamente funcional:
Dunno Robot
Aplicación que permite al usuario interactuar con el robot.
Tengo pensado implementar una versión en inglés pronto, en castellano tendrá que esperar 
(Avísame en los comentarios si la quieres cuando esté en inglés).
CÓDIGO GITHUB:
A continuación se muestra el back-end desarrollado, recuerda que debe configurarse con la configuración de la integración dialogFlow.
No sé si ayuda, pero aquí está el código para la aplicación front-end también, la hice en REACT (lo desaconsejo, soy horrible en la aplicación front-end, revisa el código y descubrirás por qué).
¡Eso es! ¡Comparte tu opinión en los comentarios! ¡Cualquier comentario es realmente importante para mí!
The post [CREANDO UN ROBOT — PARTE 1]- Enseñándolo a chatear first appeared on Planeta Chatbot.
]]>